STEP: corpus check

solvecraft-cli step-corpus and cargo xtask step-corpus [DIR]: open every
Fusion oracle part.step and compare body count, volume and area (1e-3) and
face count with Fusion's measurements; docs/step-import.md (29/29 pass).
solvecraft-cli eval/run accept STEP files and --in FILE.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01AS5Tn3xieewUSg3uxrMVdL

apps/solvecraft-cli/src/main.rs

@@ -1,13 +1,14 @@
 //! SolveCraft headless command line.
 //!
 //! ```text
-//! solvecraft-cli run <script.json|design.solvecraft> [--out FILE]... [--save FILE] [--quiet]
-//! solvecraft-cli eval <script.json|design.solvecraft>        (alias: inspect) measurements as JSON
+//! solvecraft-cli run <script.json|design.solvecraft|part.step> [--in design|part.step] [--out FILE]... [--save FILE] [--quiet]
+//! solvecraft-cli eval <script.json|design.solvecraft|part.step> (alias: inspect) measurements as JSON
 //! solvecraft-cli snapshot <script|design> --out shot.png [--width W] [--height H] [--view iso|front|top|…]
 //! solvecraft-cli exec <command> [json-params]                 run one command on an empty design
 //! solvecraft-cli commands                                     the command registry as JSON
 //! solvecraft-cli recipe <recipe.json>                         translate an oracle recipe to a script
 //! solvecraft-cli oracle <case-dir>...                         replay recipes and compare with measure.json
+//! solvecraft-cli step-corpus <case-dir>...                    import part.step and compare with measure.json
 //! solvecraft-cli mcp [--in design|script] [--connect HOST:PORT] MCP server on stdio (docs/mcp.md)
 //! ```
 #![deny(clippy::unwrap_used, clippy::expect_used, clippy::panic, clippy::unimplemented, clippy::todo, clippy::unreachable)]
@@ -23,13 +24,15 @@ use solvecraft_engine::Session;
 use solvecraft_engine::render::{StandardView, render_png};
 
 const USAGE: &str = "usage:
-  solvecraft-cli run <script.json|design.solvecraft> [--out FILE]... [--save FILE] [--quiet] [--results]
-  solvecraft-cli eval <script.json|design.solvecraft>     (alias: inspect)
+  solvecraft-cli run <script.json|design.solvecraft|part.step> [--in design.solvecraft|part.step] [--out FILE]... [--save FILE] [--quiet] [--results]
+  solvecraft-cli run --in <design.solvecraft|part.step> [--out FILE]...
+  solvecraft-cli eval <script.json|design.solvecraft|part.step>     (alias: inspect; or --in FILE)
   solvecraft-cli snapshot <script|design> --out shot.png [--width W] [--height H] [--view iso|front|back|top|bottom|left|right]
   solvecraft-cli exec <command> [json-params]
   solvecraft-cli commands
   solvecraft-cli recipe <recipe.json>
   solvecraft-cli oracle <case-dir>... [--json]
+  solvecraft-cli step-corpus <case-dir>... [--json]
   solvecraft-cli mcp [--in design.solvecraft|script.json] [--connect 127.0.0.1:PORT]
 ";
 
@@ -49,6 +52,7 @@ fn main() -> ExitCode {
             recipe::to_script(&v).map(|s| println!("{}", pretty(&s)))
         }),
         Some("oracle") => oracle::run(&args[1..]),
+        Some("step-corpus") => oracle::step_corpus(&args[1..]),
         Some("mcp") => cmd_mcp(&args[1..]),
         Some("--version" | "-V") => {
             println!("solvecraft-cli {}", env!("CARGO_PKG_VERSION"));
@@ -74,10 +78,14 @@ pub fn read_json(path: &str) -> Result<Value, String> {
     serde_json::from_str(&s).map_err(|e| format!("{path}: {e}"))
 }
 
-/// A session from a design file, a command script, or an oracle recipe.
+/// A session from a design file, a STEP file, a command script, or an oracle recipe.
 pub fn load(path: &str) -> Result<Session, String> {
-    let v = read_json(path)?;
     let mut s = Session::default();
+    if solvecraft_engine::io::is_step_path(path) {
+        s.execute("doc.open", &json!({"path": path})).map_err(|e| e.to_string())?;
+        return Ok(s);
+    }
+    let v = read_json(path)?;
     if v.get("format").and_then(Value::as_str).is_some_and(|f| f.starts_with("solvecraft")) {
         s.execute("doc.open", &json!({"path": path})).map_err(|e| e.to_string())?;
     } else if v.get("features").is_some() && v.get("commands").is_none() {
@@ -97,17 +105,45 @@ fn flags<'a>(args: &'a [String], name: &str) -> Vec<&'a str> {
     args.windows(2).filter(|w| w[0] == name).map(|w| w[1].as_str()).collect()
 }
 
+/// The first argument that is not an option or an option's value.
+fn positional(args: &[String]) -> Option<&String> {
+    let mut i = 0;
+    while let Some(a) = args.get(i) {
+        if a.starts_with("--") {
+            i += if matches!(a.as_str(), "--quiet" | "--results") { 1 } else { 2 };
+            continue;
+        }
+        return Some(a);
+    }
+    None
+}
+
 fn cmd_run(args: &[String]) -> Result<(), String> {
-    let path = args.first().ok_or_else(|| USAGE.to_string())?;
+    let base = flag(args, "--in");
+    let path = positional(args);
+    if path.is_none() && base.is_none() {
+        return Err(USAGE.to_string());
+    }
+    // `--in` starts from a design or STEP file; the positional script then runs on top of it.
+    let mut s = match base {
+        Some(b) => load(b)?,
+        None => Session::default(),
+    };
     if args.iter().any(|a| a == "--results") {
         // Print every command's result (scripts only).
-        let v = read_json(path)?;
-        let mut s = Session::default();
+        let v = read_json(path.ok_or("--results needs a script")?)?;
         let r = s.run_script(&v).map_err(|e| e.to_string())?;
         println!("{}", pretty(&Value::Array(r)));
         return Ok(());
     }
-    let mut s = load(path)?;
+    match (base, path) {
+        (Some(_), Some(p)) => {
+            let v = read_json(p)?;
+            s.run_script(&v).map_err(|e| e.to_string())?;
+        }
+        (None, Some(p)) => s = load(p)?,
+        _ => {}
+    }
     for out in flags(args, "--out") {
         s.execute("ExportCommand", &json!({"path": out})).map_err(|e| e.to_string())?;
     }
@@ -122,7 +158,7 @@ fn cmd_run(args: &[String]) -> Result<(), String> {
 }
 
 fn cmd_eval(args: &[String]) -> Result<(), String> {
-    let path = args.first().ok_or_else(|| USAGE.to_string())?;
+    let path = flag(args, "--in").or_else(|| positional(args).map(String::as_str)).ok_or_else(|| USAGE.to_string())?;
     let mut s = load(path)?;
     let m = s.execute("MeasureCommand", &json!({})).map_err(|e| e.to_string())?;
     let d = s.execute("document.inspect", &json!({})).map_err(|e| e.to_string())?;

apps/solvecraft-cli/src/oracle.rs

@@ -1,4 +1,5 @@
-//! Replay oracle recipes and compare with Fusion's measurements.
+//! Replay oracle recipes and compare with Fusion's measurements; import oracle STEP files and
+//! compare them with the same measurements.
 
 use serde_json::{Value, json};
 
@@ -46,38 +47,99 @@ fn check_case(dir: &str) -> Value {
     json!({"case": name, "pass": pass, "checks": checks})
 }
 
+/// Import a case's `part.step` (as File → Open does) and compare with Fusion's measurements:
+/// body count, volume and area (relative 1e-3) and the faces read from the file.
+fn check_step_case(dir: &str) -> Value {
+    let name = std::path::Path::new(dir).file_name().map(|x| x.to_string_lossy().to_string()).unwrap_or_default();
+    let sp = format!("{dir}/part.step");
+    let want = match read_json(&format!("{dir}/measure.json")) {
+        Ok(m) => m,
+        Err(e) => return json!({"case": name, "pass": false, "error": e}),
+    };
+    let t0 = std::time::Instant::now();
+    let mut s = solvecraft_engine::Session::default();
+    let opened = match s.execute("doc.open", &json!({"path": sp})) {
+        Ok(v) => v,
+        Err(e) => return json!({"case": name, "pass": false, "error": e.to_string()}),
+    };
+    let got = match s.execute("MeasureCommand", &json!({})) {
+        Ok(m) => m,
+        Err(e) => return json!({"case": name, "pass": false, "error": e.to_string()}),
+    };
+    let ms = t0.elapsed().as_secs_f64() * 1000.0;
+    // Faces read from the file (the kernel may split a face that wraps around a closed surface).
+    let file_faces = std::fs::read(&sp)
+        .ok()
+        .and_then(|b| solvecraft_engine::kernel::step_import_shared(&String::from_utf8_lossy(&b)).ok())
+        .map(|imp| imp.bodies.iter().map(|b| b.file_faces).sum::<usize>() as f64);
+    let mut checks = Vec::new();
+    let mut pass = true;
+    let mut num = |what: &str, g: Option<f64>, w: Option<f64>, rel: f64| {
+        let ok = match (g, w) {
+            (Some(g), Some(w)) => (g - w).abs() <= rel * w.abs().max(1.0),
+            _ => false,
+        };
+        pass &= ok;
+        checks.push(json!({"check": what, "got": g, "want": w, "ok": ok}));
+    };
+    num("body_count", got["body_count"].as_f64(), want["body_count"].as_f64(), 0.0);
+    num("volume_mm3", got["total"]["volume_mm3"].as_f64(), want["total"]["volume_mm3"].as_f64(), REL_TOL);
+    num("area_mm2", got["total"]["area_mm2"].as_f64(), want["total"]["area_mm2"].as_f64(), REL_TOL);
+    num("faces", file_faces, want["total"]["faces"].as_f64(), 0.0);
+    json!({
+        "case": name, "pass": pass, "checks": checks, "ms": ms,
+        "bodies": opened["bodies"], "warnings": opened["warnings"],
+        "info": {"kernel_faces_merged": got["total"]["faces"], "edges": got["total"]["edges"], "want_edges": want["total"]["edges"], "vertices": got["total"]["vertices"], "want_vertices": want["total"]["vertices"]},
+    })
+}
+
+pub fn step_corpus(args: &[String]) -> Result<(), String> {
+    let dirs: Vec<&String> = args.iter().filter(|a| !a.starts_with("--")).collect();
+    if dirs.is_empty() {
+        return Err("step-corpus: give one or more case directories (each with part.step and measure.json)".into());
+    }
+    let results: Vec<Value> = dirs.iter().map(|d| check_step_case(d)).collect();
+    report(args, &results);
+    let failed = results.iter().filter(|r| !r["pass"].as_bool().unwrap_or(false)).count();
+    if failed > 0 { Err(format!("{failed} STEP case(s) failed")) } else { Ok(()) }
+}
+
+fn report(args: &[String], results: &[Value]) {
+    if args.iter().any(|a| a == "--json") {
+        println!("{}", serde_json::to_string_pretty(&Value::Array(results.to_vec())).unwrap_or_default());
+        return;
+    }
+    for r in results {
+        let status = if r["pass"].as_bool().unwrap_or(false) {
+            "PASS"
+        } else if r["skipped"].as_bool().unwrap_or(false) {
+            "SKIP"
+        } else {
+            "FAIL"
+        };
+        let detail: Vec<String> = r["checks"]
+            .as_array()
+            .into_iter()
+            .flatten()
+            .filter(|c| !c["ok"].as_bool().unwrap_or(false))
+            .map(|c| format!("{} got {} want {}", c["check"].as_str().unwrap_or(""), c["got"], c["want"]))
+            .collect();
+        let err = r["error"].as_str().map(|e| format!(" ({e})")).unwrap_or_default();
+        println!(
+            "{status} {}{err}{}",
+            r["case"].as_str().unwrap_or(""),
+            if detail.is_empty() { String::new() } else { format!(": {}", detail.join("; ")) }
+        );
+    }
+}
+
 pub fn run(args: &[String]) -> Result<(), String> {
     let dirs: Vec<&String> = args.iter().filter(|a| !a.starts_with("--")).collect();
     if dirs.is_empty() {
         return Err("oracle: give one or more case directories".into());
     }
     let results: Vec<Value> = dirs.iter().map(|d| check_case(d)).collect();
-    if args.iter().any(|a| a == "--json") {
-        println!("{}", serde_json::to_string_pretty(&Value::Array(results.clone())).unwrap_or_default());
-    } else {
-        for r in &results {
-            let status = if r["pass"].as_bool().unwrap_or(false) {
-                "PASS"
-            } else if r["skipped"].as_bool().unwrap_or(false) {
-                "SKIP"
-            } else {
-                "FAIL"
-            };
-            let detail: Vec<String> = r["checks"]
-                .as_array()
-                .into_iter()
-                .flatten()
-                .filter(|c| !c["ok"].as_bool().unwrap_or(false))
-                .map(|c| format!("{} got {} want {}", c["check"].as_str().unwrap_or(""), c["got"], c["want"]))
-                .collect();
-            let err = r["error"].as_str().map(|e| format!(" ({e})")).unwrap_or_default();
-            println!(
-                "{status} {}{err}{}",
-                r["case"].as_str().unwrap_or(""),
-                if detail.is_empty() { String::new() } else { format!(": {}", detail.join("; ")) }
-            );
-        }
-    }
+    report(args, &results);
     let failed = results.iter().filter(|r| !r["pass"].as_bool().unwrap_or(false) && !r["skipped"].as_bool().unwrap_or(false)).count();
     if failed > 0 { Err(format!("{failed} oracle case(s) failed")) } else { Ok(()) }
 }