hecks 2.8.0 → 3.0.0

data/rust/build/src/pipeline.rs

@@ -0,0 +1,264 @@
+//! Rust port of `RustProjectPipeline.call` (`rust/project_rust_pipeline.rb`) —
+//! this crate's own orchestration core.
+
+use std::path::{Path, PathBuf};
+
+use crate::build_artifact;
+use crate::cargo_sync;
+use crate::json::Json;
+use crate::lineage_pass;
+use crate::optional_pass;
+use crate::resolve;
+use crate::sidecars;
+use crate::subprocess;
+use crate::tmp::TempDir;
+
+pub struct Options {
+    pub build_native: bool,
+    pub build_wasm: bool,
+}
+
+struct Chapter {
+    mod_name: String,
+    source_label: String,
+    ir_text: String,
+}
+
+const META_SOURCE_LABEL: &str = "the self-hosted language (lib/hecks/language/bluebook)";
+
+pub fn run(root: &Path, domain: &str, opts: &Options) -> Result<(), String> {
+    let parser_dir = root.join("rust/parser");
+    let codegen_dir = root.join("rust/codegen");
+    ensure_binaries_built(&parser_dir, &codegen_dir)?;
+    let parser_bin = parser_dir.join("target/debug/hecks-parse");
+    let codegen_bin = codegen_dir.join("target/debug/hecks-codegen");
+
+    let domain_path = PathBuf::from(domain);
+    let target_mod_name = domain_path
+        .file_name()
+        .and_then(|s| s.to_str())
+        .ok_or_else(|| format!("could not determine a module name from domain path {domain:?}"))?
+        .to_string();
+
+    // Same guard, same reason as hecks project_rust's own default path (R5)
+    // — see `cargo_sync::valid_domain_mod_name`'s own header.
+    if !cargo_sync::valid_domain_mod_name(&target_mod_name) {
+        return Err(format!(
+            "domain name {target_mod_name:?} (from {domain:?}) can't be used as-is — it has to double as a Rust \
+             module identifier and a Cargo feature name, and this one is either not a plain lowercase identifier, \
+             is a Rust keyword, or collides with a reserved Cargo.toml key. Rename the domain directory."
+        ));
+    }
+
+    let bluebook_directory = domain_path.join("bluebook");
+    let bluebook_paths = resolve::bluebook_files(&bluebook_directory)?;
+    let first_bluebook = bluebook_paths.first().ok_or_else(|| format!("{} has no .bluebook files", domain_path.display()))?;
+    let hecksagon_candidate = bluebook_directory.join(format!("{target_mod_name}.hecksagon"));
+    let hecksagon_path = hecksagon_candidate.is_file().then_some(hecksagon_candidate);
+    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 mut target_files = Vec::new();
+    for path in bluebook_paths {
+        if resolve::header_chapter_name(&path)? == target_chapter_name {
+            target_files.push(path);
+        }
+    }
+
+    let (uses_framework_names, uses_embryonaut_bluebook_names) = match &hecksagon_path {
+        Some(p) => (
+            resolve::resolve_uses_framework(&parser_bin, &target_chapter_name, p)?,
+            resolve::resolve_uses_embryonaut_bluebook(&parser_bin, &target_chapter_name, p)?,
+        ),
+        None => (Vec::new(), Vec::new()),
+    };
+
+    if let Some(p) = &hecksagon_path {
+        target_files.push(p.clone());
+    }
+    let target_ir_text = parse_chapter_with_optionals(&parser_bin, &target_chapter_name, &target_files)?;
+    // Only the target chapter gets a `lineage` key — a framework chapter 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}"))?;
+    lineage_pass::run(&mut target_ir, hecksagon_path.as_deref(), world_path.as_deref(), root)?;
+    let target_ir_text = crate::json::write(&target_ir);
+
+    // Every other chapter's `uses_framework` names, resolved through the
+    // same directory listing (`resolve::framework_members`) the Ruby
+    // pipeline itself calls.
+    let framework_members = resolve::framework_members(root)?;
+    let mut chapters: Vec<Chapter> = Vec::new();
+    for fw_name in &uses_framework_names {
+        let fw_path = framework_members
+            .iter()
+            .find(|(name, _)| name == fw_name)
+            .map(|(_, path)| path.clone())
+            .ok_or_else(|| {
+                let known: Vec<&str> = framework_members.iter().map(|(n, _)| n.as_str()).collect();
+                format!("hecks-build: uses_framework {fw_name:?} names no known framework member — known: {}", known.join(", "))
+            })?;
+        let fw_chapter_name = resolve::header_chapter_name(&fw_path)?;
+        if &fw_chapter_name != fw_name {
+            return Err(format!(
+                "hecks-build: {} declares chapter {fw_chapter_name:?}, but uses_framework named {fw_name:?}",
+                fw_path.display()
+            ));
+        }
+        let fw_ir_text = parse_chapter_with_optionals(&parser_bin, &fw_chapter_name, std::slice::from_ref(&fw_path))?;
+        chapters.push(Chapter {
+            mod_name: fw_name.to_lowercase(),
+            source_label: format!("{domain} (uses_framework {fw_name:?})"),
+            ir_text: fw_ir_text,
+        });
+    }
+
+    // Every vendored package's `uses_embryonaut_bluebook` names, resolved the
+    // same way `EmbryonautBluebook.load!` (Ruby) resolves them — without this,
+    // a vendored chapter would silently drop from the output.
+    for pkg_name in &uses_embryonaut_bluebook_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 = resolve::pascal(pkg_name);
+        if pkg_chapter_name != expected_chapter_name {
+            return Err(format!(
+                "hecks-build: {} declares chapter {pkg_chapter_name:?}, but uses_embryonaut_bluebook {pkg_name:?} \
+                 expects {expected_chapter_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 {
+                pkg_bluebooks.push(path.clone());
+            }
+        }
+        let pkg_ir_text = parse_chapter_with_optionals(&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
+            // would diverge the moment a package name has an underscore.
+            mod_name: expected_chapter_name.to_lowercase(),
+            source_label: format!("{domain} (uses_embryonaut_bluebook {pkg_name:?})"),
+            ir_text: pkg_ir_text,
+        });
+    }
+
+    // Guards against a `uses_framework`- and a `uses_embryonaut_bluebook`-
+    // derived entry sharing a `mod_name`, which would silently overwrite one
+    // chapter's sidecars with another's.
+    {
+        let mut seen: Vec<&str> = Vec::new();
+        for c in &chapters {
+            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 \
+                     most one of them",
+                    c.mod_name, target_chapter_name
+                ));
+            }
+            seen.push(&c.mod_name);
+        }
+    }
+
+    // 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_with_optionals(&parser_bin, "Bluebook", &grammar_files)?;
+
+    let out_root = 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'
+    // own: multiple domains coexist on disk, so only this run's own
+    // directories are wiped first.
+    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 {
+        remove_dir_if_exists(&out_root.join(&c.mod_name))?;
+    }
+
+    let tmp = TempDir::new("hecks-build-codegen")?;
+
+    let meta_ir_path = tmp.path().join("meta_ir.json");
+    std::fs::write(&meta_ir_path, &meta_ir_text).map_err(|e| format!("writing {}: {e}", meta_ir_path.display()))?;
+    run_codegen_full(&codegen_bin, &[out_root.to_string_lossy().to_string(), "meta".to_string(), META_SOURCE_LABEL.to_string(), meta_ir_path.to_string_lossy().to_string()])?;
+
+    let target_ir_path = tmp.path().join("target_ir.json");
+    std::fs::write(&target_ir_path, &target_ir_text).map_err(|e| format!("writing {}: {e}", target_ir_path.display()))?;
+
+    let mut codegen_args = vec![
+        out_root.to_string_lossy().to_string(),
+        target_mod_name.clone(),
+        domain.to_string(),
+        target_ir_path.to_string_lossy().to_string(),
+    ];
+    let mut chapter_ir_paths = Vec::new();
+    for (idx, c) in chapters.iter().enumerate() {
+        let ir_path = tmp.path().join(format!("chapter_{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());
+        codegen_args.push(c.source_label.clone());
+        codegen_args.push(ir_path.to_string_lossy().to_string());
+        chapter_ir_paths.push(ir_path);
+    }
+    run_codegen_full(&codegen_bin, &codegen_args)?;
+
+    sidecars::write(&out_root.join("meta"), &meta_ir_text, META_SOURCE_LABEL)?;
+    sidecars::write(&out_root.join(&target_mod_name), &target_ir_text, domain)?;
+    for c in &chapters {
+        sidecars::write(&out_root.join(&c.mod_name), &c.ir_text, &c.source_label)?;
+    }
+
+    let cargo_toml_path = root.join("rust/Cargo.toml");
+    cargo_sync::run(&out_root, &cargo_toml_path, &target_mod_name)?;
+
+    let rust_dir = root.join("rust");
+    if opts.build_native {
+        build_artifact::build_native(&rust_dir)?;
+    }
+    if opts.build_wasm {
+        build_artifact::build_wasm(root, &rust_dir, &target_mod_name)?;
+    }
+
+    Ok(())
+}
+
+// Parses via `hecks-parse chapter`, then runs `optional_pass::run` and
+// re-serializes — matching `derive_append_optionals` (Ruby).
+fn parse_chapter_with_optionals(parser_bin: &Path, chapter_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()];
+    args.extend(files.iter().map(|p| p.to_string_lossy().to_string()));
+    let arg_refs: Vec<&str> = args.iter().map(String::as_str).collect();
+
+    let stdout = subprocess::run_capture(&parser_bin_str, &arg_refs)?;
+    let mut ir = Json::parse(&stdout).map_err(|e| format!("parsing hecks-parse chapter output for {chapter_name}: {e}"))?;
+    optional_pass::run(&mut ir);
+    Ok(crate::json::write(&ir))
+}
+
+fn run_codegen_full(codegen_bin: &Path, args: &[String]) -> Result<(), String> {
+    let codegen_bin_str = codegen_bin.to_string_lossy().to_string();
+    let mut full_args: Vec<String> = vec!["full".to_string()];
+    full_args.extend(args.iter().cloned());
+    let arg_refs: Vec<&str> = full_args.iter().map(String::as_str).collect();
+    subprocess::run(&codegen_bin_str, &arg_refs)
+}
+
+fn remove_dir_if_exists(path: &Path) -> Result<(), String> {
+    if path.exists() {
+        std::fs::remove_dir_all(path).map_err(|e| format!("removing {}: {e}", path.display()))?;
+    }
+    Ok(())
+}
+
+// Plain `cargo build` (debug profile) in each sibling crate directory,
+// output suppressed unless it fails.
+fn ensure_binaries_built(parser_dir: &Path, codegen_dir: &Path) -> Result<(), String> {
+    subprocess::cargo_build_quiet(parser_dir)?;
+    subprocess::cargo_build_quiet(codegen_dir)?;
+    Ok(())
+}

data/rust/build/src/reserved_names.rs

@@ -0,0 +1,76 @@
+// GENERATED by hecks project_reserved_names from the RustReservedWord and
+// CargoReservedName vocabularies (lib/hecks/language/bluebook/
+// vocabulary.bluebook). Do not hand-edit — re-run hecks project_reserved_names.
+
+/// The `RustReservedWord` vocabulary, 49 entries.
+pub const RUST_KEYWORDS: &[&str] = &[
+    "as",
+    "break",
+    "const",
+    "continue",
+    "crate",
+    "dyn",
+    "else",
+    "enum",
+    "extern",
+    "false",
+    "fn",
+    "for",
+    "if",
+    "impl",
+    "in",
+    "let",
+    "loop",
+    "match",
+    "mod",
+    "move",
+    "mut",
+    "pub",
+    "ref",
+    "return",
+    "self",
+    "Self",
+    "static",
+    "struct",
+    "super",
+    "trait",
+    "true",
+    "type",
+    "unsafe",
+    "use",
+    "where",
+    "while",
+    "abstract",
+    "become",
+    "box",
+    "do",
+    "final",
+    "macro",
+    "override",
+    "priv",
+    "typeof",
+    "unsized",
+    "virtual",
+    "yield",
+    "try",
+];
+
+/// The `CargoReservedName` vocabulary, 16 entries.
+pub const CARGO_RESERVED_DOMAIN_NAMES: &[&str] = &[
+    "name",
+    "version",
+    "edition",
+    "path",
+    "authors",
+    "license",
+    "description",
+    "default",
+    "features",
+    "package",
+    "lib",
+    "bin",
+    "dependencies",
+    "dev-dependencies",
+    "build-dependencies",
+    "workspace",
+];

data/rust/build/src/resolve.rs

@@ -0,0 +1,124 @@
+//! Chapter resolution: header names, framework members and vendored packages, found by text
+//! scanning and directory listing rather than by executing any DSL.
+
+use std::path::{Path, PathBuf};
+
+use crate::json::Json;
+use crate::subprocess;
+
+pub fn bluebook_files(directory: &Path) -> Result<Vec<PathBuf>, String> {
+    let mut files = Vec::new();
+    for entry in std::fs::read_dir(directory).map_err(|e| format!("reading {}: {e}", directory.display()))? {
+        let path = entry.map_err(|e| format!("reading {}: {e}", directory.display()))?.path();
+        if path.extension().and_then(|extension| extension.to_str()) == Some("bluebook") {
+            files.push(path);
+        }
+    }
+    files.sort();
+    Ok(files)
+}
+
+// Plain text scan of the `Hecks.bluebook "Name"` line; the file is never executed.
+pub fn header_chapter_name(path: &Path) -> Result<String, String> {
+    let text = std::fs::read_to_string(path).map_err(|e| format!("reading {}: {e}", path.display()))?;
+    for line in text.lines() {
+        let trimmed = line.trim_start();
+        if let Some(rest) = trimmed.strip_prefix("Hecks.bluebook") {
+            if let Some(name) = extract_quoted(rest) {
+                return Ok(name);
+            }
+        }
+    }
+    Err(format!("{} has no 'Hecks.bluebook \"Name\"' header", path.display()))
+}
+
+fn extract_quoted(rest: &str) -> Option<String> {
+    let after_ws = rest.trim_start();
+    if !after_ws.starts_with('"') {
+        return None;
+    }
+    let inner = &after_ws[1..];
+    let end = inner.find('"')?;
+    Some(inner[..end].to_string())
+}
+
+// A directory listing, so a member is never missing from a hand-kept list.
+pub fn framework_members(root: &Path) -> Result<Vec<(String, PathBuf)>, String> {
+    let dir = root.join("lib/hecks/framework/bluebook");
+    let mut members = Vec::new();
+    for entry in std::fs::read_dir(&dir).map_err(|e| format!("reading {}: {e}", dir.display()))? {
+        let entry = entry.map_err(|e| format!("reading {}: {e}", dir.display()))?;
+        let path = entry.path();
+        if path.extension().and_then(|e| e.to_str()) != Some("bluebook") {
+            continue;
+        }
+        let stem = path.file_stem().and_then(|s| s.to_str()).unwrap_or("").to_string();
+        members.push((pascal(&stem), path));
+    }
+    members.sort();
+    Ok(members)
+}
+
+pub fn pascal(text: &str) -> String {
+    text.split('_')
+        .map(|part| {
+            let mut chars = part.chars();
+            match chars.next() {
+                Some(first) => first.to_uppercase().collect::<String>() + chars.as_str(),
+                None => String::new(),
+            }
+        })
+        .collect()
+}
+
+// Discovery, not a mirrored filename list, so a new concept cannot drift from this pipeline.
+pub fn grammar_files(root: &Path) -> Result<Vec<PathBuf>, String> {
+    let dir = root.join("lib/hecks/language/bluebook");
+    bluebook_files(&dir)
+}
+
+pub fn resolve_uses_framework(parser_bin: &Path, chapter_name: &str, hecksagon_path: &Path) -> Result<Vec<String>, String> {
+    resolve_json(parser_bin, chapter_name, hecksagon_path, "uses_framework")
+}
+
+pub fn resolve_uses_embryonaut_bluebook(parser_bin: &Path, chapter_name: &str, hecksagon_path: &Path) -> Result<Vec<String>, String> {
+    resolve_json(parser_bin, chapter_name, hecksagon_path, "uses_embryonaut_bluebook")
+}
+
+fn resolve_json(parser_bin: &Path, chapter_name: &str, hecksagon_path: &Path, key: &str) -> Result<Vec<String>, String> {
+    let parser_bin_str = parser_bin.to_string_lossy().to_string();
+    let hecksagon_str = hecksagon_path.to_string_lossy().to_string();
+    let out = subprocess::run_capture(&parser_bin_str, &["resolve", "--chapter", chapter_name, &hecksagon_str])?;
+    let json = Json::parse(&out).map_err(|e| format!("parsing 'hecks-parse resolve' output: {e}\n{out}"))?;
+    let names = json.get(key).map(Json::each).unwrap_or(&[]);
+    Ok(names.iter().filter_map(Json::as_str).map(str::to_string).collect())
+}
+
+pub fn vendored_bluebook_files(domain: &Path, pkg_name: &str) -> Result<Vec<PathBuf>, String> {
+    let dir = domain.join("vendor").join("embryonaut_bluebooks").join(pkg_name).join("bluebook");
+    if !dir.is_dir() {
+        return Err(format!(
+            "uses_embryonaut_bluebook {pkg_name:?} names no vendored bluebook at {} — run hecks vendor {pkg_name}",
+            dir.display()
+        ));
+    }
+    bluebook_files(&dir)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn pascal_cases_snake_case_stems() {
+        assert_eq!(pascal("governance"), "Governance");
+        assert_eq!(pascal("console_settings"), "ConsoleSettings");
+        assert_eq!(pascal("identity"), "Identity");
+    }
+
+    #[test]
+    fn extracts_the_quoted_chapter_name() {
+        assert_eq!(extract_quoted(r#" "Pizzas""#), Some("Pizzas".to_string()));
+        assert_eq!(extract_quoted(r#" "Console Settings" do"#), Some("Console Settings".to_string()));
+    }
+}

data/rust/build/src/root.rs

@@ -0,0 +1,25 @@
+//! Finds the repo root by walking up from the current directory to `hecks.gemspec`.
+//! Not `current_exe()`, which would tie the crate to its build output layout.
+
+use std::path::{Path, PathBuf};
+
+pub fn find() -> Result<PathBuf, String> {
+    let start = std::env::current_dir().map_err(|e| format!("reading current directory: {e}"))?;
+    find_from(&start)
+}
+
+fn find_from(start: &Path) -> Result<PathBuf, String> {
+    let mut dir = start.to_path_buf();
+    loop {
+        if dir.join("hecks.gemspec").is_file() {
+            return Ok(dir);
+        }
+        if !dir.pop() {
+            return Err(format!(
+                "could not find the hecks repo root (no 'hecks.gemspec' found walking up from {}) — \
+                 run hecks-build from inside the repo",
+                start.display()
+            ));
+        }
+    }
+}

data/rust/build/src/sidecars.rs

@@ -0,0 +1,73 @@
+//! Writes each chapter's `ir.json` and `metadata.rs` sidecars.
+
+/// Renders `text` as a Rust string literal. Not Ruby's `String#inspect`, whose `\#{` and bare
+/// `\uXXXX` escapes are not valid Rust.
+pub fn rust_string_literal(text: &str) -> String {
+    let mut out = String::with_capacity(text.len() + 2);
+    out.push('"');
+    for ch in text.chars() {
+        match ch {
+            '"' => out.push_str("\\\""),
+            '\\' => out.push_str("\\\\"),
+            '\n' => out.push_str("\\n"),
+            '\r' => out.push_str("\\r"),
+            '\t' => out.push_str("\\t"),
+            c if (c as u32) < 0x20 || (c as u32) == 0x7f => {
+                out.push_str(&format!("\\u{{{:x}}}", c as u32));
+            }
+            c => out.push(c),
+        }
+    }
+    out.push('"');
+    out
+}
+
+pub fn write(mod_dir: &std::path::Path, ir_text: &str, source_label: &str) -> Result<(std::path::PathBuf, std::path::PathBuf), String> {
+    std::fs::create_dir_all(mod_dir).map_err(|e| format!("creating {}: {e}", mod_dir.display()))?;
+
+    let ir_json_path = mod_dir.join("ir.json");
+    std::fs::write(&ir_json_path, ir_text).map_err(|e| format!("writing {}: {e}", ir_json_path.display()))?;
+
+    let metadata_path = mod_dir.join("metadata.rs");
+    let mut contents = String::new();
+    // Attribution text matches both Ruby pipelines so generated trees diff clean.
+    contents.push_str("// GENERATED by hecks project_rust — ");
+    contents.push_str(source_label);
+    contents.push_str("'s own canonical IR,\n");
+    contents.push_str("// embedded for runtime self-description. Not read by any dispatch\n");
+    contents.push_str("// function in this module — introspection only.\n");
+    contents.push_str("pub const IR_JSON: &str = ");
+    contents.push_str(&rust_string_literal(ir_text));
+    contents.push_str(";\n");
+    std::fs::write(&metadata_path, contents).map_err(|e| format!("writing {}: {e}", metadata_path.display()))?;
+
+    Ok((ir_json_path, metadata_path))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn escapes_quotes_backslashes_and_newlines() {
+        assert_eq!(rust_string_literal("abc\ndef"), "\"abc\\ndef\"");
+        assert_eq!(rust_string_literal("tab\there"), "\"tab\\there\"");
+        assert_eq!(rust_string_literal("quote\"here"), "\"quote\\\"here\"");
+        assert_eq!(rust_string_literal("back\\slash"), "\"back\\\\slash\"");
+    }
+
+    // A literal `#{` or `#@` passes through unchanged; Ruby's `\#{` is not a valid Rust escape.
+    // escape exists at all).
+    #[test]
+    fn leaves_a_literal_hash_brace_and_hash_at_untouched() {
+        assert_eq!(rust_string_literal("cost #{threshold}"), "\"cost #{threshold}\"");
+        assert_eq!(rust_string_literal("ivar #@foo"), "\"ivar #@foo\"");
+    }
+
+    // A control character becomes a braced `\u{...}`; Ruby's bare `\uXXXX` is not valid Rust.
+    #[test]
+    fn escapes_control_characters_as_braced_lowercase_hex() {
+        assert_eq!(rust_string_literal("\u{1}\u{1f}"), "\"\\u{1}\\u{1f}\"");
+        assert_eq!(rust_string_literal("\u{7f}"), "\"\\u{7f}\"");
+    }
+}

data/rust/build/src/subprocess.rs

@@ -0,0 +1,51 @@
+//! Subprocess helpers: run a command, check its exit status, surface stderr on failure.
+//! The crate reaches `hecks-parse`, `hecks-codegen` and `cargo` only through these.
+
+use std::path::Path;
+use std::process::{Command, Stdio};
+
+pub fn run_capture(program: &str, args: &[&str]) -> Result<String, String> {
+    let output = Command::new(program).args(args).output().map_err(|e| format!("running {program} {}: {e}", args.join(" ")))?;
+    if !output.status.success() {
+        return Err(format!(
+            "{program} {} failed:\n{}",
+            args.join(" "),
+            String::from_utf8_lossy(&output.stderr)
+        ));
+    }
+    String::from_utf8(output.stdout).map_err(|e| format!("{program} {}: stdout was not valid UTF-8: {e}", args.join(" ")))
+}
+
+pub fn run(program: &str, args: &[&str]) -> Result<(), String> {
+    let status = Command::new(program).args(args).status().map_err(|e| format!("running {program} {}: {e}", args.join(" ")))?;
+    if !status.success() {
+        return Err(format!("{program} {} failed", args.join(" ")));
+    }
+    Ok(())
+}
+
+pub fn run_in(dir: &Path, program: &str, args: &[&str]) -> Result<(), String> {
+    let status = Command::new(program)
+        .args(args)
+        .current_dir(dir)
+        .status()
+        .map_err(|e| format!("running {program} {} in {}: {e}", args.join(" "), dir.display()))?;
+    if !status.success() {
+        return Err(format!("{program} {} failed in {}", args.join(" "), dir.display()));
+    }
+    Ok(())
+}
+
+pub fn cargo_build_quiet(dir: &Path) -> Result<(), String> {
+    let status = Command::new("cargo")
+        .arg("build")
+        .current_dir(dir)
+        .stdout(Stdio::null())
+        .stderr(Stdio::inherit())
+        .status()
+        .map_err(|e| format!("running cargo build in {}: {e}", dir.display()))?;
+    if !status.success() {
+        return Err(format!("cargo build failed in {} — run it there directly to see why", dir.display()));
+    }
+    Ok(())
+}

data/rust/build/src/tmp.rs

@@ -0,0 +1,31 @@
+//! A minimal, dependency-free RAII temp directory — `Dir.mktmpdir`'s
+//! Rust equivalent, hand-rolled rather than pulling in the `tempfile`
+//! crate (this crate's own no-dependency discipline, matching
+//! `rust/parser`'s and `rust/codegen`'s own Cargo.toml).
+
+use std::path::{Path, PathBuf};
+
+pub struct TempDir {
+    path: PathBuf,
+}
+
+impl TempDir {
+    pub fn new(prefix: &str) -> Result<Self, String> {
+        let base = std::env::temp_dir();
+        let pid = std::process::id();
+        let nanos = std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).map(|d| d.as_nanos()).unwrap_or(0);
+        let path = base.join(format!("{prefix}-{pid}-{nanos}"));
+        std::fs::create_dir_all(&path).map_err(|e| format!("creating temp dir {}: {e}", path.display()))?;
+        Ok(Self { path })
+    }
+
+    pub fn path(&self) -> &Path {
+        &self.path
+    }
+}
+
+impl Drop for TempDir {
+    fn drop(&mut self) {
+        let _ = std::fs::remove_dir_all(&self.path);
+    }
+}

data/rust/codegen/.cargo/config.toml

@@ -0,0 +1,3 @@
+# Link with lld; this crate has no native C library dependencies.
+[target.x86_64-unknown-linux-gnu]
+rustflags = ["-C", "link-arg=-fuse-ld=lld"]

data/rust/codegen/.gitignore

@@ -0,0 +1 @@
+/target

data/rust/codegen/Cargo.lock

@@ -0,0 +1,7 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 4
+
+[[package]]
+name = "hecks_codegen"
+version = "0.1.0"