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 <[email protected]>
Claude-Session: https://claude.ai/code/session_01AS5Tn3xieewUSg3uxrMVdL

xtask/src/main.rs

@@ -21,6 +21,9 @@ commands:
                   xtask/data/fusion-catalog.tsv from plan/fusion/menu-tree.json)
   oracle          replay plan/fusion/oracle/*/recipe.json and compare with measure.json;
                   writes docs/oracle.md
+  step-corpus [DIR]
+                  import every DIR/*/part.step (default plan/fusion/oracle) and compare
+                  with measure.json; writes docs/step-import.md
   wasm            cargo check every library crate and the web app for wasm32-unknown-unknown
   ci              fmt --check, clippy -D warnings, test, assets, layers, wasm (stops at first failure)
 ";
@@ -33,6 +36,7 @@ fn main() -> ExitCode {
         Some("assets") => assets::run(&root()),
         Some("parity") => parity::run(&root(), rest.contains(&"--refresh")),
         Some("oracle") => cmd_oracle(),
+        Some("step-corpus") => cmd_step_corpus(rest.first().copied()),
         Some("ci") => cmd_ci(),
         Some("wasm") => cmd_wasm(),
         Some("-h" | "--help" | "help") | None => {
@@ -180,6 +184,81 @@ fn cmd_wasm() -> Result<(), String> {
     Ok(())
 }
 
+/// Import every oracle STEP file (exported by Fusion) and compare with Fusion's measurements;
+/// write docs/step-import.md.
+fn cmd_step_corpus(dir: Option<&str>) -> Result<(), String> {
+    let dir = dir.map(PathBuf::from).unwrap_or_else(|| root().join("plan/fusion/oracle"));
+    let mut cases: Vec<PathBuf> = std::fs::read_dir(&dir)
+        .map_err(|e| format!("{}: {e} (the oracle data is local, in plan/fusion/oracle)", dir.display()))?
+        .flatten()
+        .map(|e| e.path())
+        .filter(|p| p.join("part.step").is_file() && p.join("measure.json").is_file())
+        .collect();
+    cases.sort();
+    if cases.is_empty() {
+        return Err(format!("no cases with part.step and measure.json in {}", dir.display()));
+    }
+    let mut cmd = cargo();
+    cmd.args(["run", "-q", "--release", "-p", "solvecraft-cli", "--", "step-corpus", "--json"]);
+    for c in &cases {
+        cmd.arg(c);
+    }
+    let out = cmd.output().map_err(|e| format!("solvecraft-cli: {e}"))?;
+    let results: serde_json::Value =
+        serde_json::from_slice(&out.stdout).map_err(|e| format!("step-corpus JSON: {e}\n{}", String::from_utf8_lossy(&out.stderr)))?;
+    let list = results.as_array().cloned().unwrap_or_default();
+    let pass = list.iter().filter(|r| r["pass"].as_bool().unwrap_or(false)).count();
+    let check =
+        |r: &serde_json::Value, name: &str| r["checks"].as_array().and_then(|c| c.iter().find(|c| c["check"] == name).cloned()).unwrap_or_default();
+    let num = |v: &serde_json::Value| v.as_f64().map(|x| format!("{x:.3}")).unwrap_or_else(|| "–".into());
+    let mut md = format!(
+        "# STEP import\n\n\
+SolveCraft reads STEP (ISO 10303-21; AP203, AP214 and AP242 geometry) with its own reader in `crates/kernel/src/step_in` \
+(written from the public standards; no third-party STEP code). A STEP file becomes an **Import** base feature on the \
+timeline: it holds the file's B-rep (the STEP text is kept in the design, so the design reopens without the file) and \
+later features — fillets, holes, cuts sketched on its faces, shells — build on its bodies.\n\n\
+- **Open**: File → Open (`doc.open`) accepts `.step`/`.stp` in any case and starts a new design; `solvecraft part.step`; \
+`solvecraft-cli eval part.step`, `solvecraft-cli run script.json --in part.step`; the MCP `open` tool.\n\
+- **Insert** into the current design: File → Insert STEP… or SOLID → INSERT (`FusionImportCommandFromToolbar {{path}}`).\n\
+- **Drag and drop** a STEP file on the window: inserted when the design has features, opened otherwise.\n\n\
+Read: manifold solid breps (with voids), faceted breps, shell-based surface models; planes, cylinders, cones, spheres, \
+tori, B-spline and rational B-spline surfaces (with knots, Bézier, uniform, quasi-uniform), surfaces of revolution and \
+linear extrusion, trimmed surfaces; lines, circles, ellipses, B-spline curves, polylines, trimmed/surface/seam curves; \
+length and angle units (SI prefixes, conversion-based units such as inches); product names (body names come from the \
+solid's name, else the product's); surface colours; assemblies (next-assembly-usage occurrences placed by item-defined \
+transformations, and mapped items) — the product tree is kept in the feature for the components milestone. Files are \
+untrusted: sizes, entity counts and nesting are capped and every kernel call is guarded. What cannot be read becomes a \
+warning on the feature (a face left out gives an open body); not read yet: offset surfaces, pcurve-only edges.\n\n\
+## Fusion corpus\n\nGenerated by `cargo xtask step-corpus`. Each case is a part exported from Fusion as STEP (AP214; kept locally in `plan/fusion/oracle/`, never committed). SolveCraft opens `part.step` exactly as File → Open does (an Import base feature) and compares with Fusion's own measurements: body count, volume and area (relative tolerance 1e-3) and the number of faces read from the file.\n\n**{pass} / {} files pass.**\n\n| Case | Result | Bodies | Volume mm³ (got / Fusion) | Area mm² (got / Fusion) | Faces (got / Fusion) | ms | Notes |\n|---|---|---|---|---|---|---|---|\n",
+        list.len()
+    );
+    for r in &list {
+        let status = if r["pass"].as_bool().unwrap_or(false) { "pass" } else { "FAIL" };
+        let (v, a, f) = (check(r, "volume_mm3"), check(r, "area_mm2"), check(r, "faces"));
+        let bodies: Vec<String> = r["bodies"].as_array().into_iter().flatten().filter_map(|b| b.as_str().map(str::to_string)).collect();
+        let mut notes: Vec<String> = r["warnings"].as_array().into_iter().flatten().filter_map(|w| w.as_str().map(|w| w.replace('|', "/"))).collect();
+        if let Some(e) = r["error"].as_str() {
+            notes.push(e.replace('|', "/"));
+        }
+        md += &format!(
+            "| {} | {status} | {} | {} / {} | {} / {} | {} / {} | {:.0} | {} |\n",
+            r["case"].as_str().unwrap_or(""),
+            bodies.join(", "),
+            num(&v["got"]),
+            num(&v["want"]),
+            num(&a["got"]),
+            num(&a["want"]),
+            f["got"].as_f64().map(|x| format!("{x}")).unwrap_or_else(|| "–".into()),
+            f["want"].as_f64().map(|x| format!("{x}")).unwrap_or_else(|| "–".into()),
+            r["ms"].as_f64().unwrap_or(0.0),
+            notes.join("; ")
+        );
+    }
+    std::fs::write(root().join("docs/step-import.md"), md).map_err(|e| format!("docs/step-import.md: {e}"))?;
+    println!("step-corpus: {pass}/{} files pass → docs/step-import.md", list.len());
+    if pass == list.len() { Ok(()) } else { Err(format!("{} STEP file(s) failed", list.len() - pass)) }
+}
+
 fn cmd_ci() -> Result<(), String> {
     let mut c = cargo();
     c.args(["fmt", "--all", "--", "--check"]);