hecks 3.9.1 → 3.11.0

data/rust/.gitignore

@@ -1,2 +1,8 @@
 /target
 /dist
+
+# Generated from the bluebooks by `hecks regeneration_run.regenerate_corpus --confirm`; mod.rs and the
+# Cargo features stay tracked. pizzas stays committed: its translations carry SQL only the Ruby
+# toolchain compiles, so hecks-build cannot reproduce it.
+/src/generated/*/
+!/src/generated/pizzas/

data/rust/Cargo.toml

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

data/rust/build/src/binding_pass.rs

@@ -0,0 +1,103 @@
+//! Rust port of the binding facts `lib/hecks/rust_build/project_rust/target_ir.rb` adds beside the
+//! declared IR: `persistence`, `translations` and `source_text`. The capability seams
+//! (authorization, identity, payments, ...) are `seams_pass`'s.
+
+use std::collections::HashMap;
+use std::path::{Path, PathBuf};
+
+use crate::json::Json;
+use crate::lineage_pass;
+use crate::translation_pass;
+
+/// Sets `persistence`, the first of the binding facts, in `TargetIr#call`'s order.
+pub fn run(ir: &mut Json, hecksagon_path: Option<&Path>, world_path: Option<&Path>) -> Result<(), String> {
+    let chapter_name = ir.get("name").and_then(Json::as_str).unwrap_or_default().to_string();
+    let persistence = persistence(ir, &chapter_name, hecksagon_path, world_path)?;
+    ir.set("persistence", persistence);
+    Ok(())
+}
+
+/// Sets `translations` and `source_text`, after the capability seams so the key order matches
+/// `TargetIr#call`.
+///
+/// `translations` carries each `translations/*.bluebook` edge with its precompiled SQL, from
+/// `translation_pass`; an edge using a rule kind that pass does not compile is refused, never
+/// shipped without its SQL. A `translates` declaration in a bluebook is refused outright.
+pub fn finish(ir: &mut Json, bluebook_files: &[PathBuf], bluebook_dir: &Path) -> Result<(), String> {
+    let mut texts = Vec::new();
+    for path in bluebook_files {
+        let text = read(path)?;
+        if text.lines().any(declares_translation) {
+            return Err(format!(
+                "{} declares a translation; hecks-build cannot compile its SQL yet, so generate this domain with the Ruby toolchain",
+                path.display()
+            ));
+        }
+        texts.push(text);
+    }
+    ir.set("translations", Json::Array(translation_pass::edges(bluebook_dir)?));
+    if !texts.is_empty() {
+        ir.set("source_text", Json::String(texts.join("\n")));
+    }
+    Ok(())
+}
+
+fn declares_translation(line: &str) -> bool {
+    let line = line.trim_start();
+    line.starts_with("translates") || line.starts_with("translation ")
+}
+
+fn persistence(ir: &Json, chapter: &str, hecksagon: Option<&Path>, world: Option<&Path>) -> Result<Json, String> {
+    let (binds, hecksagon_default) = match hecksagon {
+        Some(path) => {
+            let text = read(path)?;
+            (lineage_pass::persistence_binds(&text), domain_default(&text, chapter))
+        }
+        None => (HashMap::new(), None),
+    };
+    let world_default = match world {
+        Some(path) => lineage_pass::default_adapter_name(&read(path)?, chapter),
+        None => None,
+    };
+    let declared = hecksagon_default.or(world_default);
+    let mut aggregates = Vec::new();
+    for aggregate in ir.get("aggregates").map(Json::each).unwrap_or(&[]) {
+        let name = aggregate.get("name").and_then(Json::as_str).unwrap_or_default().to_string();
+        let adapter = match (binds.get(&name), &declared, hecksagon.is_some()) {
+            (Some(adapter), _, _) => adapter.clone(),
+            (None, Some(adapter), _) => adapter.clone(),
+            (None, None, false) => "Memory".to_string(),
+            (None, None, true) => {
+                return Err(format!("{chapter}::{name} has no persisted_by bind, and its hecksagon names no default adapter"));
+            }
+        };
+        aggregates.push(Json::Object(vec![
+            ("name".to_string(), Json::String(name.clone())),
+            ("storage_name".to_string(), Json::String(lineage_pass::snake_case(&name))),
+            ("adapter".to_string(), Json::String(adapter)),
+        ]));
+    }
+    Ok(Json::Object(vec![("aggregates".to_string(), Json::Array(aggregates))]))
+}
+
+// The bare `persisted_by "X"` line of the chapter's own `Hecks.hecksagon` block: every aggregate
+// without a bind of its own inherits it. The last one in the block wins.
+fn domain_default(text: &str, chapter: &str) -> Option<String> {
+    let mut in_chapter = false;
+    let mut found = None;
+    for line in text.lines() {
+        if let Some(rest) = line.strip_prefix("Hecks.hecksagon") {
+            in_chapter = rest.contains(&format!("\"{chapter}\""));
+            continue;
+        }
+        let Some(rest) = line.trim_start().strip_prefix("persisted_by ") else { continue };
+        let Some(open) = rest.find('"').filter(|_| in_chapter) else { continue };
+        let quoted = &rest[open + 1..];
+        found = quoted.find('"').map(|close| quoted[..close].to_string());
+    }
+    found
+}
+
+fn read(path: &Path) -> Result<String, String> {
+    std::fs::read_to_string(path).map_err(|e| format!("reading {}: {e}", path.display()))
+}

data/rust/build/src/cargo_sync.rs

@@ -212,6 +212,12 @@ fn is_default_line(line_content: &str) -> bool {
     trimmed.strip_prefix("default").map(|rest| rest.trim_start().starts_with('=')).unwrap_or(false)
 }
 
+/// Rewrites only the root `mod.rs`, for a generation into a directory other than `rust/src/generated`.
+pub fn write_mod_only(out_root: &Path, target_mod_name: &str) -> Result<(), String> {
+    let (all_dirs, domains) = scan_generated_dirs(out_root)?;
+    write_root_mod(out_root, &all_dirs, &domains, target_mod_name)
+}
+
 /// Rewrites the root `mod.rs` and syncs `rust/Cargo.toml`'s `[features]` for the domains on disk.
 pub fn run(out_root: &Path, cargo_toml_path: &Path, target_mod_name: &str) -> Result<(), String> {
     let (all_dirs, domains) = scan_generated_dirs(out_root)?;

data/rust/build/src/lineage_pass.rs

@@ -57,7 +57,7 @@ pub fn run(ir: &mut Json, hecksagon_path: Option<&Path>, world_path: Option<&Pat
 }
 
 // Skips any line naming `role:` — only a role-less bind is authoritative.
-fn persistence_binds(text: &str) -> HashMap<String, String> {
+pub(crate) fn persistence_binds(text: &str) -> HashMap<String, String> {
     let mut binds = HashMap::new();
 
     for line in text.lines() {
@@ -87,7 +87,7 @@ fn persistence_binds(text: &str) -> HashMap<String, String> {
 
 // Only lines inside the target chapter's own `Hecks.world` block count; the
 // last `default_adapter` there wins, matching the Ruby builder.
-fn default_adapter_name(text: &str, chapter: &str) -> Option<String> {
+pub(crate) fn default_adapter_name(text: &str, chapter: &str) -> Option<String> {
     let mut in_target_world = false;
     let mut found = None;
 
@@ -182,7 +182,7 @@ fn top_level_class_name(text: &str) -> Option<String> {
 
 // Hand-ported `Naming.snake` (Ruby): split acronym boundaries, then camelCase
 // boundaries, then downcase — no regex dependency.
-fn snake_case(name: &str) -> String {
+pub(crate) fn snake_case(name: &str) -> String {
     let after_pass1 = split_acronym_boundaries(name);
     let after_pass2 = split_camel_boundaries(&after_pass1);
     after_pass2.to_ascii_lowercase()

data/rust/build/src/main.rs

@@ -1,4 +1,4 @@
-//! `hecks-build <domain> [--wasm] [--no-build]` compiles a domain's `.bluebook` to a binary.
+//! `hecks-build <domain> [--wasm] [--no-build] [--out <dir>]` compiles a domain's `.bluebook` to a binary.
 //! `<domain>` is a domain directory such as `examples/pizzas`; `--wasm` also cross-compiles to
 //! `wasm32-wasip1`, and `--no-build` generates source only.
 
@@ -9,13 +9,16 @@ mod cargo_sync;
 #[allow(dead_code)]
 #[path = "../../codegen/src/json.rs"]
 mod json;
+mod binding_pass;
 mod lineage_pass;
 mod pipeline;
 mod reserved_names;
 mod resolve;
 mod root;
+mod seams_pass;
 mod subprocess;
 mod tmp;
+mod translation_pass;
 
 use std::process::ExitCode;
 
@@ -34,20 +37,29 @@ fn run(args: &[String]) -> Result<(), String> {
     let mut domain: Option<String> = None;
     let mut build_wasm = false;
     let mut no_build = false;
+    let mut out_dir: Option<String> = None;
 
-    for arg in args {
+    let mut iter = args.iter();
+    while let Some(arg) = iter.next() {
         match arg.as_str() {
+            "--out" => out_dir = Some(iter.next().ok_or("--out needs a directory")?.clone()),
             "--wasm" => build_wasm = true,
             "--no-build" => no_build = true,
             other if !other.starts_with("--") && domain.is_none() => domain = Some(other.to_string()),
-            other => return Err(format!("unrecognized argument {other:?} — usage: hecks-build <domain> [--wasm] [--no-build]")),
+            other => return Err(format!("unrecognized argument {other:?} — usage: hecks-build <domain> [--wasm] [--no-build] [--out <dir>]")),
         }
     }
 
-    let domain = domain.ok_or_else(|| "usage: hecks-build <domain> [--wasm] [--no-build]".to_string())?;
+    let domain = domain.ok_or_else(|| "usage: hecks-build <domain> [--wasm] [--no-build] [--out <dir>]".to_string())?;
     let root = root::find()?;
 
-    let opts = pipeline::Options { build_native: !no_build, build_wasm: build_wasm && !no_build };
+    // `--out` generates the module tree into that directory only: no `Cargo.toml` rewrite, no
+    // native or wasm build, so a `build.rs` can call it from inside a cargo build.
+    let opts = pipeline::Options {
+        build_native: !no_build && out_dir.is_none(),
+        build_wasm: build_wasm && !no_build && out_dir.is_none(),
+        out_dir: out_dir.map(std::path::PathBuf::from),
+    };
 
     pipeline::run(&root, &domain, &opts)
 }

data/rust/build/src/pipeline.rs

@@ -3,17 +3,20 @@
 
 use std::path::{Path, PathBuf};
 
+use crate::binding_pass;
 use crate::build_artifact;
 use crate::cargo_sync;
 use crate::json::Json;
 use crate::lineage_pass;
 use crate::resolve;
+use crate::seams_pass;
 use crate::subprocess;
 use crate::tmp::TempDir;
 
 pub struct Options {
     pub build_native: bool,
     pub build_wasm: bool,
+    pub out_dir: Option<PathBuf>,
 }
 
 struct Chapter {
@@ -58,10 +61,19 @@ pub fn run(root: &Path, domain: &str, opts: &Options) -> Result<(), String> {
 
     let target_chapter_name = resolve::header_chapter_name(first_bluebook)?;
     let mut target_files = Vec::new();
+    // Chapters declared beside the target but not attached to it: the registry still loads them, so
+    // one may provide a capability (payments) the target uses.
+    let mut sibling_files: Vec<(String, Vec<PathBuf>)> = Vec::new();
     for path in bluebook_paths {
-        if resolve::header_chapter_name(&path)? == target_chapter_name {
-            target_files.push(path);
+        let chapter = resolve::header_chapter_name(&path)?;
+        if chapter != target_chapter_name {
+            match sibling_files.iter_mut().find(|(name, _)| *name == chapter) {
+                Some((_, files)) => files.push(path),
+                None => sibling_files.push((chapter, vec![path])),
+            }
+            continue;
         }
+        target_files.push(path);
     }
 
     let (gem_chapter_names, vendored_package_names) = match &hecksagon_path {
@@ -72,6 +84,7 @@ pub fn run(root: &Path, domain: &str, opts: &Options) -> Result<(), String> {
         None => (Vec::new(), Vec::new()),
     };
 
+    let source_files = target_files.clone();
     if let Some(p) = &hecksagon_path {
         target_files.push(p.clone());
     }
@@ -81,7 +94,7 @@ pub fn run(root: &Path, domain: &str, opts: &Options) -> Result<(), String> {
     // rather than chaining a live object through both passes.
     let mut target_ir = Json::parse(&target_ir_text).map_err(|e| format!("re-parsing target ir.json for lineage: {e}"))?;
     lineage_pass::run(&mut target_ir, hecksagon_path.as_deref(), world_path.as_deref(), root)?;
-    let target_ir_text = crate::json::write(&target_ir);
+    binding_pass::run(&mut target_ir, hecksagon_path.as_deref(), world_path.as_deref())?;
 
     // Every other chapter the gem supplies by `attaches "Name"`, resolved through the
     // same directory listing (`resolve::framework_members`) the Ruby
@@ -150,6 +163,22 @@ pub fn run(root: &Path, domain: &str, opts: &Options) -> Result<(), String> {
         });
     }
 
+    // A chapter declared in the domain's own directory is a chapter of the build too, as every
+    // bluebook the registry loads is; its ports come from its own block of the domain's hecksagon.
+    // The registry loads the directory's bluebooks before it resolves what the hecksagon attaches,
+    // so they come first.
+    let mut siblings = Vec::new();
+    for (name, files) in &sibling_files {
+        let mut sources = files.clone();
+        sources.extend(hecksagon_path.iter().cloned());
+        siblings.push(Chapter {
+            mod_name: name.to_lowercase(),
+            source_label: format!("{domain} (attaches {name:?})"),
+            ir_text: parse_chapter(&parser_bin, name, &sources)?,
+        });
+    }
+    chapters.splice(0..0, siblings);
+
     // Guards against a gem-chapter and a vendored-package
     // entry sharing a `mod_name`, which would silently overwrite one
     // chapter's sidecars with another's.
@@ -167,12 +196,22 @@ pub fn run(root: &Path, domain: &str, opts: &Options) -> Result<(), String> {
         }
     }
 
+    // The capability seams read the attached chapters' own `provides`, so they are decided only
+    // once every chapter is loaded; `translations` and `source_text` close the binding facts.
+    let mut member_irs = Vec::new();
+    for c in &chapters {
+        member_irs.push(Json::parse(&c.ir_text).map_err(|e| format!("re-parsing {} ir.json for its seams: {e}", c.mod_name))?);
+    }
+    seams_pass::run(&mut target_ir, &member_irs)?;
+    binding_pass::finish(&mut target_ir, &source_files, &bluebook_directory)?;
+    let target_ir_text = crate::json::write(&target_ir);
+
     // The self-hosted language, compiled in too, under the same "Bluebook"
     // chapter name.
     let grammar_files = resolve::grammar_files(root)?;
     let meta_ir_text = parse_chapter(&parser_bin, "Bluebook", &grammar_files)?;
 
-    let out_root = root.join("rust/src/generated");
+    let out_root = opts.out_dir.clone().unwrap_or_else(|| root.join("rust/src/generated"));
     std::fs::create_dir_all(&out_root).map_err(|e| format!("creating {}: {e}", out_root.display()))?;
 
     // Scoped clearing — identical reasoning to both Ruby pipelines'
@@ -212,7 +251,11 @@ pub fn run(root: &Path, domain: &str, opts: &Options) -> Result<(), String> {
     run_codegen_full(&codegen_bin, &codegen_args)?;
 
     let cargo_toml_path = root.join("rust/Cargo.toml");
-    cargo_sync::run(&out_root, &cargo_toml_path, &target_mod_name)?;
+    if opts.out_dir.is_some() {
+        cargo_sync::write_mod_only(&out_root, &target_mod_name)?;
+    } else {
+        cargo_sync::run(&out_root, &cargo_toml_path, &target_mod_name)?;
+    }
 
     let rust_dir = root.join("rust");
     if opts.build_native {

data/rust/build/src/seams_pass.rs

@@ -0,0 +1,123 @@
+//! Rust port of `Exporter::Bindings` (`lib/hecks/projector/exporter/bindings.rb`) and the provider
+//! lookups of `Registry::Providers`: which attached chapter answers each capability the target
+//! domain uses, read from every chapter's own `provides` entries in its IR.
+
+use crate::json::Json;
+
+/// One capability's exported shape: the keys it exports as qualified verbs, then each derived
+/// `name => verb key` aggregate, in the order `Bindings` builds them, then its optional marks.
+struct Seam {
+    capability: &'static str,
+    export_as: &'static str,
+    verbs: &'static [&'static str],
+    aggregates: &'static [(&'static str, &'static str)],
+    marks: &'static [&'static str],
+}
+
+// In `TargetIr::SEAMS` order, which is the order the keys land in `ir.json`.
+const SEAMS: &[Seam] = &[
+    Seam { capability: "authorization", export_as: "authorization", verbs: &["grant", "assignments"], aggregates: &[("assignment_aggregate", "assignments")], marks: &[] },
+    Seam { capability: "membership", export_as: "membership", verbs: &["admit", "grant", "people"], aggregates: &[("aggregate", "admit")], marks: &[] },
+    Seam { capability: "identity", export_as: "identity", verbs: &["register", "link", "resolve"], aggregates: &[], marks: &[] },
+    Seam {
+        capability: "newsletter",
+        export_as: "newsletter",
+        verbs: &["subscribe", "add_name", "confirm", "unsubscribe"],
+        aggregates: &[("aggregate", "subscribe")],
+        marks: &["awaiting_confirmation", "receives_issues", "left"],
+    },
+    Seam {
+        capability: "newsletter_issues",
+        export_as: "newsletter_issues",
+        verbs: &["send_issue", "record_delivery"],
+        aggregates: &[("issue_aggregate", "send_issue"), ("delivery_aggregate", "record_delivery")],
+        marks: &[],
+    },
+    Seam { capability: "payments", export_as: "payments", verbs: &["initiate", "succeeded", "failed"], aggregates: &[("aggregate", "initiate")], marks: &["holds_seat"] },
+    Seam {
+        capability: "registrations",
+        export_as: "registrations",
+        verbs: &["schedule", "request"],
+        aggregates: &[("event_aggregate", "schedule"), ("registration_aggregate", "request")],
+        marks: &["frees_seat"],
+    },
+    Seam {
+        capability: "payment_connection",
+        export_as: "payment_connection",
+        verbs: &["connect", "reconnect", "disconnect", "suspend", "resume", "enable", "disable"],
+        aggregates: &[("aggregate", "connect")],
+        marks: &[],
+    },
+];
+
+/// Sets each seam some chapter provides on `target`, leaving it out otherwise, as
+/// `TargetIr#add_seams` does. `members` are the chapters the target attaches, in attach order; the
+/// target itself is searched first.
+pub fn run(target: &mut Json, members: &[Json]) -> Result<(), String> {
+    let mut chapters: Vec<Json> = vec![target.clone()];
+    chapters.extend(members.iter().cloned());
+
+    let mut membership = false;
+    let mut identity = false;
+    for seam in SEAMS {
+        let Some(provider) = chapters.iter().find(|chapter| provision(chapter, seam.capability).is_some()) else { continue };
+        let exported = export(seam, provider);
+        membership |= seam.capability == "membership";
+        identity |= seam.capability == "identity";
+        target.set(seam.export_as, exported);
+    }
+    if membership && !identity {
+        return Err(format!(
+            "{} provides membership but not identity — rust/host Google sign-in cannot register or link an identity from ir.json. \
+             Attach Identity so the hecksagon, not a deploy-time guess, names the identity verbs.",
+            name_of(target)
+        ));
+    }
+    Ok(())
+}
+
+fn export(seam: &Seam, provider: &Json) -> Json {
+    let name = name_of(provider);
+    let entries = provision(provider, seam.capability).unwrap_or_default();
+    let verb = |key: &str| entries.iter().find(|(k, _)| k == key).map(|(_, v)| format!("{name}::{v}"));
+
+    let mut out = vec![("provider".to_string(), Json::String(name.clone()))];
+    for key in seam.verbs {
+        out.push((key.to_string(), verb(key).map_or(Json::Null, Json::String)));
+    }
+    for (exported, key) in seam.aggregates {
+        let aggregate = verb(key).map(|v| v.split('.').next().unwrap_or_default().to_string());
+        out.push((exported.to_string(), aggregate.map_or(Json::Null, Json::String)));
+    }
+    for key in seam.marks {
+        if let Some(states) = marked_states(provider, entries.iter().find(|(k, _)| k == key).map(|(_, v)| v.as_str())) {
+            out.push((key.to_string(), states));
+        }
+    }
+    Json::Object(out)
+}
+
+// `[(key, verb)]` this chapter provides under `capability`, or `None` when it provides none.
+fn provision(chapter: &Json, capability: &str) -> Option<Vec<(String, String)>> {
+    let entries: Vec<(String, String)> = chapter
+        .get("provides")
+        .map(Json::each)
+        .unwrap_or(&[])
+        .iter()
+        .filter(|entry| entry.get("capability").and_then(Json::as_str) == Some(capability))
+        .filter_map(|entry| Some((entry.get("key")?.as_str()?.to_string(), entry.get("verb")?.as_str()?.to_string())))
+        .collect();
+    (!entries.is_empty()).then_some(entries)
+}
+
+// The states of the aggregate lifecycle mark a `"Aggregate.mark"` entry names; `None` when the
+// entry is not declared or the mark is.
+fn marked_states(provider: &Json, entry: Option<&str>) -> Option<Json> {
+    let (aggregate_name, mark) = entry?.split_once('.')?;
+    let aggregate = provider.get("aggregates").map(Json::each)?.iter().find(|a| a.get("name").and_then(Json::as_str) == Some(aggregate_name))?;
+    aggregate.get("lifecycle")?.get("marks")?.get(mark).cloned()
+}
+
+fn name_of(chapter: &Json) -> String {
+    chapter.get("name").and_then(Json::as_str).unwrap_or_default().to_string()
+}

data/rust/build/src/translation_pass.rs

@@ -0,0 +1,167 @@
+//! Rust port of the part of `Projector::Exporter::Translations` that a `translations/*.bluebook`
+//! edge made of renames and moves needs: the declared rules plus the SQL expression
+//! `Translation::RuleCompiler.compile_rules` builds for them.
+//!
+//! A rule kind this pass does not compile (convert, drop, retype, compute, rekey, backfill) is
+//! refused by name, so a domain never ships an edge whose SQL was silently left out.
+
+use std::path::Path;
+
+use crate::json::Json;
+
+/// One aggregate's rules, in declaration order.
+struct Aggregate {
+    name: String,
+    was: Option<String>,
+    renames: Vec<(String, String)>,
+    moves: Vec<(String, String)>,
+}
+
+/// The `translations` IR list for the `.bluebook` files under `bluebook_dir/translations`, ordered
+/// by file name (an era-step id), as the registry loads them.
+pub fn edges(bluebook_dir: &Path) -> Result<Vec<Json>, String> {
+    let Ok(entries) = std::fs::read_dir(bluebook_dir.join("translations")) else { return Ok(Vec::new()) };
+    let mut paths: Vec<_> = entries
+        .filter_map(Result::ok)
+        .map(|entry| entry.path())
+        .filter(|path| path.extension().and_then(|e| e.to_str()) == Some("bluebook"))
+        .collect();
+    paths.sort();
+    let mut edges = Vec::new();
+    for path in paths {
+        let text = std::fs::read_to_string(&path).map_err(|e| format!("reading {}: {e}", path.display()))?;
+        edges.push(edge(&text).map_err(|why| format!("{}: {why}", path.display()))?);
+    }
+    Ok(edges)
+}
+
+fn edge(text: &str) -> Result<Json, String> {
+    let mut header: Option<(String, String, String)> = None;
+    let mut aggregates: Vec<Aggregate> = Vec::new();
+    for raw in text.lines() {
+        let line = raw.trim();
+        if line.is_empty() || line.starts_with('#') || line == "end" {
+            continue;
+        }
+        if let Some(rest) = line.strip_prefix("Hecks.data_translation") {
+            header = Some((first_string(rest)?, keyword(rest, "from")?, keyword(rest, "to")?));
+        } else if let Some(rest) = line.strip_prefix("aggregate ") {
+            let was = keyword(rest, "was").ok();
+            aggregates.push(Aggregate { name: first_string(rest)?, was, renames: Vec::new(), moves: Vec::new() });
+        } else if let Some(rest) = line.strip_prefix("move ") {
+            let aggregate = aggregates.last_mut().ok_or("a move outside an aggregate")?;
+            aggregate.moves.push((first_word(rest)?, keyword(rest, "to")?));
+        } else if let Some(rest) = line.strip_prefix("rename ") {
+            let aggregate = aggregates.last_mut().ok_or("a rename outside an aggregate")?;
+            aggregate.renames.push((first_word(rest)?, keyword(rest, "to")?));
+        } else {
+            return Err(format!(
+                "hecks-build cannot compile the translation rule `{line}` yet (only rename and move are ported), \
+                 so generate this domain with the Ruby toolchain"
+            ));
+        }
+    }
+    let (domain, from, to) = header.ok_or("no Hecks.data_translation header")?;
+    Ok(Json::Object(vec![
+        ("domain".into(), Json::String(domain)),
+        ("from".into(), Json::String(from)),
+        ("to".into(), Json::String(to)),
+        ("retired".into(), Json::Array(Vec::new())),
+        ("aggregates".into(), Json::Array(aggregates.iter().map(aggregate_json).collect())),
+    ]))
+}
+
+fn aggregate_json(aggregate: &Aggregate) -> Json {
+    let renames = aggregate.renames.iter().map(|(old, new)| (old.clone(), Json::String(new.clone()))).collect();
+    let moves = aggregate
+        .moves
+        .iter()
+        .map(|(from, to)| Json::Object(vec![("from".into(), Json::String(from.clone())), ("to".into(), Json::String(to.clone()))]))
+        .collect();
+    let empty = || Json::Array(Vec::new());
+    Json::Object(vec![
+        ("name".into(), Json::String(aggregate.name.clone())),
+        ("was".into(), aggregate.was.clone().map_or(Json::Null, Json::String)),
+        ("renames".into(), Json::Object(renames)),
+        ("moves".into(), Json::Array(moves)),
+        ("converts".into(), empty()),
+        ("drops".into(), empty()),
+        ("retypes".into(), empty()),
+        ("computes".into(), empty()),
+        ("rekeys".into(), empty()),
+        ("backfills".into(), empty()),
+        ("compiled_state_expression".into(), Json::String(compile(aggregate))),
+        ("compiled_id_expression".into(), Json::Null),
+    ])
+}
+
+/// `RuleCompiler.compile_rules`: renames, then moves, each wrapping the expression so far.
+fn compile(aggregate: &Aggregate) -> String {
+    let mut sql = "state".to_string();
+    for (old, new) in &aggregate.renames {
+        sql = format!("hecks_tr_rename({sql}, {}, {})", text_literal(old), text_literal(new));
+    }
+    for (from, to) in &aggregate.moves {
+        sql = format!(
+            "hecks_tr_move({sql}, {}, {}, {})",
+            path_literal(from),
+            path_literal(to),
+            text_literal(&format!("move {from} to: {to}"))
+        );
+    }
+    sql
+}
+
+fn text_literal(text: &str) -> String {
+    format!("'{}'", text.replace('\'', "''"))
+}
+
+fn path_literal(path: &str) -> String {
+    let segments: Vec<String> = path.split('.').map(text_literal).collect();
+    format!("ARRAY[{}]::text[]", segments.join(", "))
+}
+
+/// The first `"quoted"` string of `text`.
+fn first_string(text: &str) -> Result<String, String> {
+    let open = text.find('"').ok_or_else(|| format!("no quoted name in `{text}`"))?;
+    let rest = &text[open + 1..];
+    let close = rest.find('"').ok_or_else(|| format!("unterminated string in `{text}`"))?;
+    Ok(rest[..close].to_string())
+}
+
+/// The leading argument, a `:symbol` or a `"string"`, before the first comma.
+fn first_word(text: &str) -> Result<String, String> {
+    let word = text.split(',').next().unwrap_or_default().trim();
+    let word = word.strip_prefix(':').unwrap_or(word).trim_matches('"');
+    if word.is_empty() { Err(format!("no source in `{text}`")) } else { Ok(word.to_string()) }
+}
+
+/// The value of `key: value` in `text`, a string or a symbol.
+fn keyword(text: &str, key: &str) -> Result<String, String> {
+    let marker = format!("{key}:");
+    let at = text.find(&marker).ok_or_else(|| format!("no `{key}:` in `{text}`"))?;
+    let value = text[at + marker.len()..].trim_start();
+    if let Some(symbol) = value.strip_prefix(':') {
+        let end = symbol.find(|c: char| !(c.is_alphanumeric() || c == '_')).unwrap_or(symbol.len());
+        return Ok(symbol[..end].to_string());
+    }
+    first_string(value)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn compiles_moves_as_ruby_does() {
+        let text = "Hecks.data_translation \"Pizzas\", from: \"e3f3d7\", to: \"77625c\" do\n  aggregate \"Order\", was: \"Pizza\" do\n    move :price_cents, to: \"pizza.price_cents\"\n    move :size,         to: \"pizza.size\"\n  end\nend\n";
+        let json = crate::json::write(&edge(text).unwrap());
+        assert!(json.contains("hecks_tr_move(hecks_tr_move(state, ARRAY['price_cents']::text[], ARRAY['pizza', 'price_cents']::text[], 'move price_cents to: pizza.price_cents'), ARRAY['size']::text[], ARRAY['pizza', 'size']::text[], 'move size to: pizza.size')"));
+    }
+
+    #[test]
+    fn refuses_a_rule_it_cannot_compile() {
+        let text = "Hecks.data_translation \"A\", from: \"1\", to: \"2\" do\n  aggregate \"B\" do\n    compute :a, to: \"b\", sql: \"1\"\n  end\nend\n";
+        assert!(edge(text).unwrap_err().contains("cannot compile"));
+    }
+}