hecks 5.0.0 → 6.0.0

data/qa/settings.yml

@@ -61,6 +61,15 @@ generated_domains_per_tick: 2
 generated_domains_rust: true
 generated_domain_seeds: 5
 
+# The Rust kernel's mutation test, run by each tick after the generated domains (about 8 minutes).
+# The two equivalents compare positions where `<` and `<=` cannot differ.
+mutation_files:
+  - rust/src/kernel/dispatch.rs
+  - rust/src/kernel/orchestrate.rs
+mutation_equivalent:
+  - "replace < with <= in aggregate_position"
+  - "replace < with <= in entity_position"
+
 # Construct families a sweep may skip. Shrink-only: spec/fuzzing/rust_gap_manifest_spec.rb fails
 # when a family here is not declared `generated: false` by a committed manifest.
 structural_refusal_boundary: []

data/rust/Cargo.lock

@@ -11,6 +11,13 @@ dependencies = [
  "memchr",
 ]
 
+[[package]]
+name = "hecks_expr"
+version = "0.1.0"
+dependencies = [
+ "regex",
+]
+
 [[package]]
 name = "memchr"
 version = "2.8.3"
@@ -50,5 +57,5 @@ checksum = "d6f6ff9a378485b298a5286656da665ba74413d36db0979633275d2e708145d4"
 name = "rust"
 version = "0.1.0"
 dependencies = [
- "regex",
+ "hecks_expr",
 ]

data/rust/Cargo.toml

@@ -6,6 +6,9 @@
 # `--no-default-features --features <name>`.
 [features]
 default = ["reserved_names_fixture"]
+ledgerbook = []
+outbound = []
+grouped_reduction_fixture = []
 tally = []
 relay = []
 meter = []
@@ -48,14 +51,10 @@ name = "rust"
 version = "0.1.0"
 edition = "2021"
 
-# The one dependency exception to this crate's zero-Cargo-dependency
-# discipline (ADR 0012): `expression_operators/pattern_match.rs`'s `.match?`
-# needs a real, audited regex engine. `default-features = false` keeps out
-# the SIMD-driven `perf` feature; `std`/`unicode` alone cover the Ruby-
-# Regexp-style `\d`/`\w`/case-insensitive matching this grammar's own
-# predicates use.
+# The kernel's one dependency is the expression evaluator, a std-only crate of its own that the host
+# shares (ADR 0012's regex exception now lives there, for `.match?`).
 [dependencies]
-regex = { version = "1", default-features = false, features = ["std", "unicode"] }
+hecks_expr = { path = "expr" }
 
 [lib]
 name = "rust"

data/rust/build/src/binding_pass.rs

@@ -14,15 +14,15 @@ use crate::translation_pass;
 pub fn run(
     ir: &mut Json,
     hecksagon_path: Option<&Path>,
-    world_path: Option<&Path>,
+    world_default: Option<&str>,
     adapter_declarations: impl FnOnce(&Json) -> Result<Json, String>,
 ) -> Result<(), String> {
-    let chapter_name = ir
+    let declaration_name = ir
         .get("name")
         .and_then(Json::as_str)
         .unwrap_or_default()
         .to_string();
-    let persistence = persistence(ir, &chapter_name, hecksagon_path, world_path)?;
+    let persistence = persistence(ir, &declaration_name, hecksagon_path, world_default)?;
     ir.set("persistence", persistence);
     let adapters = adapter_declarations(ir)?;
     ir.set("adapters", adapters);
@@ -68,25 +68,21 @@ fn declares_translation(line: &str) -> bool {
 
 fn persistence(
     ir: &Json,
-    chapter: &str,
+    declaration: &str,
     hecksagon: Option<&Path>,
-    world: Option<&Path>,
+    world_default: Option<&str>,
 ) -> Result<Json, String> {
     let (binds, hecksagon_default) = match hecksagon {
         Some(path) => {
             let text = read(path)?;
             (
                 lineage_pass::persistence_binds(&text),
-                domain_default(&text, chapter),
+                domain_default(&text, declaration),
             )
         }
         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 declared = hecksagon_default.or_else(|| world_default.map(str::to_string));
     let mut aggregates = Vec::new();
     for aggregate in ir.get("aggregates").map_or(&[][..], Json::each) {
         let name = aggregate
@@ -99,7 +95,7 @@ fn persistence(
             (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"));
+                return Err(format!("{declaration}::{name} has no persisted_by bind, and its hecksagon names no default adapter"));
             }
         };
         aggregates.push(Json::Object(vec![
@@ -117,20 +113,20 @@ fn persistence(
     )]))
 }
 
-// The bare `persisted_by "X"` line of the chapter's own `Hecks.hecksagon` block: every aggregate
+// The bare `persisted_by "X"` line of the bluebook'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;
+fn domain_default(text: &str, declaration: &str) -> Option<String> {
+    let mut in_bluebook = 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}\""));
+            in_bluebook = rest.contains(&format!("\"{declaration}\""));
             continue;
         }
         let Some(rest) = line.trim_start().strip_prefix("persisted_by ") else {
             continue;
         };
-        let Some(open) = rest.find('"').filter(|_| in_chapter) else {
+        let Some(open) = rest.find('"').filter(|_| in_bluebook) else {
             continue;
         };
         let quoted = &rest[open + 1..];

data/rust/build/src/cargo_sync.rs

@@ -62,7 +62,7 @@ fn write_root_mod(
     out.push_str("// every OTHER domain's `pub mod` unconditionally, so one domain's own\n");
     out.push_str("// non-compiling generated code (a `has_many` field, before this fix)\n");
     out.push_str("// broke every feature's build, not just its own. A shared FRAMEWORK\n");
-    out.push_str("// chapter (governance/identity — no merged.rs of its own, so absent\n");
+    out.push_str("// bluebook (governance/identity — no merged.rs of its own, so absent\n");
     out.push_str("// from `domains`) stays unconditional: it has no single feature of its\n");
     out.push_str("// own to gate behind, and is compiled in by whichever domain(s) attach\n");
     out.push_str("// it via `attaches`.\n");

data/rust/build/src/lineage_pass.rs

@@ -9,12 +9,12 @@ use crate::json::Json;
 /// Sets `ir["lineage"]` to `{"capable_aggregates": [{"name":, "storage_name":}, ...]}`,
 /// matching `Exporter.lineage`'s own output shape.
 ///
-/// An aggregate with no `persisted_by` bind falls back to `world_path`'s own
-/// `default_adapter` for the target chapter, then to `"Memory"`.
+/// An aggregate with no `persisted_by` bind falls back to the world's `default_adapter` for the
+/// target bluebook, then to `"Memory"`.
 pub fn run(
     ir: &mut Json,
     hecksagon_path: Option<&Path>,
-    world_path: Option<&Path>,
+    world_default: Option<&str>,
     root: &Path,
 ) -> Result<(), String> {
     let binds = match hecksagon_path {
@@ -25,20 +25,7 @@ pub fn run(
         }
         None => HashMap::new(),
     };
-    let chapter_name = ir
-        .get("name")
-        .and_then(Json::as_str)
-        .unwrap_or_default()
-        .to_string();
-    let fallback_adapter = match world_path {
-        Some(path) => {
-            let text = std::fs::read_to_string(path)
-                .map_err(|e| format!("reading {}: {e}", path.display()))?;
-            default_adapter_name(&text, &chapter_name)
-        }
-        None => None,
-    }
-    .unwrap_or_else(|| "Memory".to_string());
+    let fallback_adapter = world_default.unwrap_or("Memory").to_string();
     let capable_adapters = lineage_capable_adapter_names(root)?;
 
     // Collected before `ir.set` below: Rust can't hold this borrow of `ir`
@@ -115,46 +102,6 @@ pub(crate) fn persistence_binds(text: &str) -> HashMap<String, String> {
     binds
 }
 
-// Only lines inside the target chapter's own `Hecks.world` block count; the
-// last `default_adapter` there wins, matching the Ruby builder.
-pub(crate) fn default_adapter_name(text: &str, chapter: &str) -> Option<String> {
-    let mut in_target_world = false;
-    let mut found = None;
-
-    for line in text.lines() {
-        if let Some(opened) = world_opener_name(line) {
-            in_target_world = opened == chapter;
-            continue;
-        }
-        if !in_target_world {
-            continue;
-        }
-
-        let Some(rest) = line.trim_start().strip_prefix("default_adapter") else {
-            continue;
-        };
-        if !rest.starts_with(char::is_whitespace) {
-            continue;
-        }
-        let Some(open_quote) = rest.find('"') else {
-            continue;
-        };
-        let quoted = &rest[open_quote + 1..];
-        let Some(close_quote) = quoted.find('"') else {
-            continue;
-        };
-        found = Some(quoted[..close_quote].to_string());
-    }
-
-    found
-}
-
-fn world_opener_name(line: &str) -> Option<String> {
-    let rest = line.strip_prefix("Hecks.world")?;
-    let quoted = &rest[rest.find('"')? + 1..];
-    Some(quoted[..quoted.find('"')?].to_string())
-}
-
 // Where an adapter class can live: the driven adapters, and the era plugin that holds `PostgresEra`,
 // the one adapter that declares itself lineage-capable.
 const ADAPTER_DIRS: [&str; 2] = [
@@ -265,20 +212,6 @@ mod tests {
         assert_eq!(binds.get("Statement"), None);
     }
 
-    #[test]
-    fn reads_the_default_adapter_of_the_target_chapters_own_world_only() {
-        let text = "Hecks.world \"Alpha\" do\n  # default_adapter \"Heki\"\n  default_adapter \"PostgresEra\"\nend\n\nHecks.world(\"Beta\") do\n  default_adapter \"Memory\"\nend\n";
-        assert_eq!(
-            default_adapter_name(text, "Alpha"),
-            Some("PostgresEra".to_string())
-        );
-        assert_eq!(
-            default_adapter_name(text, "Beta"),
-            Some("Memory".to_string())
-        );
-        assert_eq!(default_adapter_name(text, "Gamma"), None);
-    }
-
     #[test]
     fn declares_lineage_capable_true_matches_the_endless_method_form() {
         assert!(declares_lineage_capable_true(

data/rust/build/src/pipeline.rs

@@ -22,7 +22,7 @@ pub struct Options {
     pub out_dir: Option<PathBuf>,
 }
 
-struct Chapter {
+struct Declaration {
     mod_name: String,
     source_label: String,
     ir_text: String,
@@ -64,51 +64,65 @@ pub fn run(root: &Path, domain: &str, opts: &Options) -> Result<(), String> {
     let world_candidate = bluebook_directory.join(format!("{target_mod_name}.world"));
     let world_path = world_candidate.is_file().then_some(world_candidate);
 
-    let target_chapter_name = resolve::header_chapter_name(first_bluebook)?;
+    let target_bluebook_name = resolve::header_bluebook_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
+    // Bluebooks 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 {
-        let chapter = resolve::header_chapter_name(&path)?;
-        if chapter != target_chapter_name {
-            match sibling_files.iter_mut().find(|(name, _)| *name == chapter) {
+        let declaration = resolve::header_bluebook_name(&path)?;
+        if declaration != target_bluebook_name {
+            match sibling_files
+                .iter_mut()
+                .find(|(name, _)| *name == declaration)
+            {
                 Some((_, files)) => files.push(path),
-                None => sibling_files.push((chapter, vec![path])),
+                None => sibling_files.push((declaration, vec![path])),
             }
             continue;
         }
         target_files.push(path);
     }
 
-    let (gem_chapter_names, vendored_package_names) = match &hecksagon_path {
-        Some(p) => (
-            resolve::resolve_gem_chapters(&parser_bin, &target_chapter_name, p)?,
-            resolve::resolve_vendored_packages(&parser_bin, &target_chapter_name, p)?,
-        ),
-        None => (Vec::new(), Vec::new()),
-    };
+    // What the target attaches, read from every hecksagon beside its bluebooks, as the registry
+    // loads every one of them: a second file may attach a bluebook (banking's `bulk.hecksagon`).
+    let mut gem_bluebook_names: Vec<String> = Vec::new();
+    let mut vendored_package_names: Vec<String> = Vec::new();
+    for path in resolve::hecksagon_files(&bluebook_directory)? {
+        let gem = resolve::resolve_gem_bluebooks(&parser_bin, &target_bluebook_name, &path)?;
+        let vendored =
+            resolve::resolve_vendored_packages(&parser_bin, &target_bluebook_name, &path)?;
+        push_new(&mut gem_bluebook_names, gem);
+        push_new(&mut vendored_package_names, vendored);
+    }
 
     let source_files = target_files.clone();
     if let Some(p) = &hecksagon_path {
         target_files.push(p.clone());
     }
-    let target_ir_text = parse_chapter(&parser_bin, &target_chapter_name, &target_files)?;
-    // Only the target chapter gets a `lineage` key — a framework chapter or
+    let target_ir_text = parse_bluebook(&parser_bin, &target_bluebook_name, &target_files)?;
+    // Only the target bluebook gets a `lineage` key — a framework bluebook or
     // `meta` never does, matching `derive_lineage` (Ruby) re-`JSON.parse`ing
     // 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}"))?;
+    let declaration_name = target_ir
+        .get("name")
+        .and_then(Json::as_str)
+        .unwrap_or_default()
+        .to_string();
+    let world = world_pass::read(&declaration_name, &parser_bin, world_path.as_deref())?;
+    let world_default = world_pass::default_adapter(&world);
     lineage_pass::run(
         &mut target_ir,
         hecksagon_path.as_deref(),
-        world_path.as_deref(),
+        world_default.as_deref(),
         root,
     )?;
     binding_pass::run(
         &mut target_ir,
         hecksagon_path.as_deref(),
-        world_path.as_deref(),
+        world_default.as_deref(),
         |ir| {
             // The same two places `TargetIr#adapters` scans: the source root's `lib/` and the
             // domain's own directory.
@@ -116,19 +130,25 @@ pub fn run(root: &Path, domain: &str, opts: &Options) -> Result<(), String> {
             adapters_pass::declarations(&parser_bin, &directories, ir)
         },
     )?;
-    world_pass::run(&mut target_ir, &parser_bin, world_path.as_deref())?;
+    target_ir.set("world", world);
 
-    // Every other chapter the gem supplies by `attaches "Name"`, resolved through the
+    // Every other bluebook the gem supplies by `attaches "Name"`, resolved through the
     // same directory listing (`resolve::framework_members`) the Ruby
-    // pipeline itself calls. A gem chapter that is not a framework member (the language,
-    // Tenancy, Deploy) is loaded by the Ruby runtime alone, so it is checked and skipped.
+    // pipeline itself calls. A gem bluebook that is not a framework member (Bulk, Tenancy, Deploy)
+    // is found by its files' headers, and is a bluebook of the build as the registry loads it.
     let framework_members = resolve::framework_members(root)?;
-    let other_gem_chapters = resolve::other_gem_chapter_names(root)?;
-    let mut chapters: Vec<Chapter> = Vec::new();
-    for fw_name in &gem_chapter_names {
-        if other_gem_chapters.contains(fw_name)
+    let other_gem_bluebooks = resolve::other_gem_bluebook_names(root)?;
+    let mut declarations: Vec<Declaration> = Vec::new();
+    for fw_name in &gem_bluebook_names {
+        if other_gem_bluebooks.contains(fw_name)
             && !framework_members.iter().any(|(name, _)| name == fw_name)
         {
+            let files = resolve::other_gem_bluebook_files(root, fw_name)?;
+            declarations.push(Declaration {
+                mod_name: fw_name.to_lowercase(),
+                source_label: format!("{domain} (attaches {fw_name:?})"),
+                ir_text: parse_bluebook(&parser_bin, fw_name, &files)?,
+            });
             continue;
         }
         let fw_path = framework_members
@@ -137,23 +157,23 @@ pub fn run(root: &Path, domain: &str, opts: &Options) -> Result<(), String> {
             .map(|(_, path)| path.clone())
             .ok_or_else(|| {
                 let mut known: Vec<&str> = framework_members.iter().map(|(n, _)| n.as_str()).collect();
-                known.extend(other_gem_chapters.iter().map(String::as_str));
+                known.extend(other_gem_bluebooks.iter().map(String::as_str));
                 known.sort_unstable();
-                format!("hecks-build: attaches {fw_name:?} names no chapter the gem carries — known: {}", known.join(", "))
+                format!("hecks-build: attaches {fw_name:?} names no bluebook the gem carries — known: {}", known.join(", "))
             })?;
-        let fw_chapter_name = resolve::header_chapter_name(&fw_path)?;
-        if &fw_chapter_name != fw_name {
+        let fw_bluebook_name = resolve::header_bluebook_name(&fw_path)?;
+        if &fw_bluebook_name != fw_name {
             return Err(format!(
-                "hecks-build: {} declares chapter {fw_chapter_name:?}, but attaches named {fw_name:?}",
+                "hecks-build: {} declares bluebook {fw_bluebook_name:?}, but attaches named {fw_name:?}",
                 fw_path.display()
             ));
         }
-        let fw_ir_text = parse_chapter(
+        let fw_ir_text = parse_bluebook(
             &parser_bin,
-            &fw_chapter_name,
+            &fw_bluebook_name,
             std::slice::from_ref(&fw_path),
         )?;
-        chapters.push(Chapter {
+        declarations.push(Declaration {
             mod_name: fw_name.to_lowercase(),
             source_label: format!("{domain} (attaches {fw_name:?})"),
             ir_text: fw_ir_text,
@@ -162,36 +182,36 @@ pub fn run(root: &Path, domain: &str, opts: &Options) -> Result<(), String> {
 
     // Every vendored package's `attaches ... from: :vendor` names, resolved the
     // same way `EmbryonautBluebook.load!` (Ruby) resolves them — without this,
-    // a vendored chapter would silently drop from the output.
+    // a vendored bluebook would silently drop from the output.
     for pkg_name in &vendored_package_names {
         let pkg_files = resolve::vendored_bluebook_files(&domain_path, pkg_name)?;
-        let pkg_chapter_name = resolve::header_chapter_name(&pkg_files[0])?;
-        let expected_chapter_name = crate::hecks_naming::pascal(pkg_name);
-        if pkg_chapter_name != expected_chapter_name {
+        let pkg_bluebook_name = resolve::header_bluebook_name(&pkg_files[0])?;
+        let expected_bluebook_name = crate::hecks_naming::pascal(pkg_name);
+        if pkg_bluebook_name != expected_bluebook_name {
             return Err(format!(
-                "hecks-build: {} declares chapter {pkg_chapter_name:?}, but attaches {pkg_name:?}, from: :vendor \
-                 expects {expected_chapter_name:?}",
+                "hecks-build: {} declares bluebook {pkg_bluebook_name:?}, but attaches {pkg_name:?}, from: :vendor \
+                 expects {expected_bluebook_name:?}",
                 pkg_files[0].display()
             ));
         }
         let mut pkg_bluebooks = Vec::new();
         for path in &pkg_files {
-            if resolve::header_chapter_name(path)? == pkg_chapter_name {
+            if resolve::header_bluebook_name(path)? == pkg_bluebook_name {
                 pkg_bluebooks.push(path.clone());
             }
         }
-        let pkg_ir_text = parse_chapter(&parser_bin, &pkg_chapter_name, &pkg_bluebooks)?;
-        chapters.push(Chapter {
-            // Derived from the declared chapter name (asserted equal to
-            // `expected_chapter_name` above), not the raw `pkg_name` — that
+        let pkg_ir_text = parse_bluebook(&parser_bin, &pkg_bluebook_name, &pkg_bluebooks)?;
+        declarations.push(Declaration {
+            // Derived from the declared bluebook name (asserted equal to
+            // `expected_bluebook_name` above), not the raw `pkg_name` — that
             // would diverge the moment a package name has an underscore.
-            mod_name: expected_chapter_name.to_lowercase(),
+            mod_name: expected_bluebook_name.to_lowercase(),
             source_label: format!("{domain} (attaches {pkg_name:?}, from: :vendor)"),
             ir_text: pkg_ir_text,
         });
     }
 
-    // A chapter declared in the domain's own directory is a chapter of the build too, as every
+    // A bluebook declared in the domain's own directory is a bluebook 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.
@@ -199,35 +219,35 @@ pub fn run(root: &Path, domain: &str, opts: &Options) -> Result<(), String> {
     for (name, files) in &sibling_files {
         let mut sources = files.clone();
         sources.extend(hecksagon_path.iter().cloned());
-        siblings.push(Chapter {
+        siblings.push(Declaration {
             mod_name: name.to_lowercase(),
             source_label: format!("{domain} (attaches {name:?})"),
-            ir_text: parse_chapter(&parser_bin, name, &sources)?,
+            ir_text: parse_bluebook(&parser_bin, name, &sources)?,
         });
     }
-    chapters.splice(0..0, siblings);
+    declarations.splice(0..0, siblings);
 
-    // Guards against a gem-chapter and a vendored-package
+    // Guards against a gem-bluebook and a vendored-package
     // entry sharing a `mod_name`, which would silently overwrite one
-    // chapter's sidecars with another's.
+    // bluebook's sidecars with another's.
     {
         let mut seen: Vec<&str> = Vec::new();
-        for c in &chapters {
+        for c in &declarations {
             if seen.contains(&c.mod_name.as_str()) {
                 return Err(format!(
-                    "hecks-build: two chapters both resolve to the same generated module {:?} — attach {} to at \
+                    "hecks-build: two bluebooks both resolve to the same generated module {:?} — attach {} to at \
                      most one of them",
-                    c.mod_name, target_chapter_name
+                    c.mod_name, target_bluebook_name
                 ));
             }
             seen.push(&c.mod_name);
         }
     }
 
-    // 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.
+    // The capability seams read the attached bluebooks' own `provides`, so they are decided only
+    // once every bluebook is loaded; `translations` and `source_text` close the binding facts.
     let mut member_irs = Vec::new();
-    for c in &chapters {
+    for c in &declarations {
         member_irs.push(
             Json::parse(&c.ir_text)
                 .map_err(|e| format!("re-parsing {} ir.json for its seams: {e}", c.mod_name))?,
@@ -238,9 +258,9 @@ pub fn run(root: &Path, domain: &str, opts: &Options) -> Result<(), String> {
     let target_ir_text = crate::json::write(&target_ir);
 
     // The self-hosted language, compiled in too, under the same "Bluebook"
-    // chapter name.
+    // bluebook name.
     let grammar_files = resolve::grammar_files(root)?;
-    let meta_ir_text = parse_chapter(&parser_bin, "Bluebook", &grammar_files)?;
+    let meta_ir_text = parse_bluebook(&parser_bin, "Bluebook", &grammar_files)?;
 
     let out_root = opts
         .out_dir
@@ -255,7 +275,7 @@ pub fn run(root: &Path, domain: &str, opts: &Options) -> Result<(), String> {
     remove_dir_if_exists(&out_root.join("meta"))?;
     remove_dir_if_exists(&out_root.join("active"))?;
     remove_dir_if_exists(&out_root.join(&target_mod_name))?;
-    for c in &chapters {
+    for c in &declarations {
         remove_dir_if_exists(&out_root.join(&c.mod_name))?;
     }
 
@@ -284,8 +304,8 @@ pub fn run(root: &Path, domain: &str, opts: &Options) -> Result<(), String> {
         domain.to_string(),
         target_ir_path.to_string_lossy().to_string(),
     ];
-    for (idx, c) in chapters.iter().enumerate() {
-        let ir_path = tmp.path().join(format!("chapter_{idx}_ir.json"));
+    for (idx, c) in declarations.iter().enumerate() {
+        let ir_path = tmp.path().join(format!("bluebook_{idx}_ir.json"));
         std::fs::write(&ir_path, &c.ir_text)
             .map_err(|e| format!("writing {}: {e}", ir_path.display()))?;
         codegen_args.push(c.mod_name.clone());
@@ -307,7 +327,7 @@ pub fn run(root: &Path, domain: &str, opts: &Options) -> Result<(), String> {
         "active".to_string(),
         target_mod_name.clone(),
     ];
-    generated_dirs.extend(chapters.iter().map(|c| c.mod_name.clone()));
+    generated_dirs.extend(declarations.iter().map(|c| c.mod_name.clone()));
     rustfmt::format_generated(&out_root, &generated_dirs)?;
 
     let rust_dir = root.join("rust");
@@ -321,18 +341,27 @@ pub fn run(root: &Path, domain: &str, opts: &Options) -> Result<(), String> {
     Ok(())
 }
 
-// Parses via `hecks-parse chapter`. `hecks-codegen` marks the IR and writes its `ir.json` and
+// Appends each of `names` that `into` does not hold yet, keeping first-seen order.
+fn push_new(into: &mut Vec<String>, names: Vec<String>) {
+    for name in names {
+        if !into.contains(&name) {
+            into.push(name);
+        }
+    }
+}
+
+// Parses via `hecks-parse bluebook`. `hecks-codegen` marks the IR and writes its `ir.json` and
 // `metadata.rs` itself, so the text goes through as `hecks-parse` printed it.
-fn parse_chapter(
+fn parse_bluebook(
     parser_bin: &Path,
-    chapter_name: &str,
+    declaration_name: &str,
     files: &[PathBuf],
 ) -> Result<String, String> {
     let parser_bin_str = parser_bin.to_string_lossy().to_string();
     let mut args: Vec<String> = vec![
-        "chapter".to_string(),
-        "--chapter".to_string(),
-        chapter_name.to_string(),
+        "bluebook".to_string(),
+        "--bluebook".to_string(),
+        declaration_name.to_string(),
     ];
     args.extend(files.iter().map(|p| p.to_string_lossy().to_string()));
     let arg_refs: Vec<&str> = args.iter().map(String::as_str).collect();