Merge pull request #1458 from brett19/fix/solid-error-sm-status

fix: SolidError::sm_status and a port-invariant variant (fixes #1452)

crates/difftest/src/own_builder.rs

@@ -1616,7 +1616,9 @@ pub(crate) fn counts(b: &Brep) -> [usize; 10] {
 pub(crate) fn build_status(e: &SolidError) -> f64 {
     match e {
         SolidError::Upstream { code, .. } => f64::from(*code),
-        SolidError::InvalidInput { .. } => f64::from(solidcore::error::SM_ERR_INVALID_INPUT),
+        SolidError::InvalidInput { .. } | SolidError::PortInvariant { .. } => {
+            f64::from(solidcore::error::SM_ERR_INVALID_INPUT)
+        }
         _ => f64::from(solidcore::error::SM_ERR),
     }
 }

crates/difftest/src/ssi/engine.rs

@@ -241,7 +241,7 @@ fn decode(
 fn rust_status(e: &SolidError) -> (i64, Option<String>) {
     match e {
         SolidError::Upstream { code, .. } => (i64::from(*code), None),
-        SolidError::InvalidInput { .. } => (
+        SolidError::InvalidInput { .. } | SolidError::PortInvariant { .. } => (
             SM_ERR_INVALID_INPUT,
             Some(format!("SM_ERR_INVALID_INPUT ({e})")),
         ),

crates/difftest/src/step.rs

@@ -158,7 +158,7 @@ fn status<T>(r: &Result<T, SolidError>, notes: &mut Vec<String>) -> Result<f64,
             Err(Deferred((*unit).to_string(), (*upstream).to_string()))
         }
         Err(SolidError::Upstream { code, .. }) => Ok(f64::from(*code)),
-        Err(SolidError::InvalidInput { .. }) => {
+        Err(SolidError::InvalidInput { .. } | SolidError::PortInvariant { .. }) => {
             Ok(f64::from(solidcore::error::SM_ERR_INVALID_INPUT))
         }
         Err(e) => {

crates/difftest/src/units/blend_fillet_corner_p1.rs

@@ -391,7 +391,7 @@ fn v3(a: [f64; 3]) -> Vec3 {
 fn status_of(e: &SolidError) -> Option<f64> {
     match e {
         SolidError::Upstream { code, .. } => Some(f64::from(*code)),
-        SolidError::InvalidInput { reason, .. } if *reason != NULL_DEREF => Some(1007.0),
+        SolidError::InvalidInput { reason, .. } | SolidError::PortInvariant { reason, .. } if *reason != NULL_DEREF => Some(1007.0),
         _ => None,
     }
 }
@@ -402,7 +402,7 @@ pub(super) fn rust_err(e: &SolidError) -> Output {
     if let Some(o) = Output::unported(e) {
         return o;
     }
-    if matches!(e, SolidError::InvalidInput { reason, .. } if *reason == NULL_DEREF) {
+    if matches!(e, SolidError::InvalidInput { reason, .. } | SolidError::PortInvariant { reason, .. } if *reason == NULL_DEREF) {
         return Output::err("refused");
     }
     match status_of(e) {
@@ -930,7 +930,7 @@ fn run_rust(i: &Inputs) -> Result<Output, HarnessError> {
                     match corner::check_nx1_degeneracy(&k, &mut t.brep, v, e) {
                         Ok(f) => Ok(vec![flag(f)]),
                         Err(e) if e.is_unported() => Err(e),
-                        Err(e) if matches!(&e, SolidError::InvalidInput { reason, .. } if *reason == NULL_DEREF) => {
+                        Err(e) if matches!(&e, SolidError::InvalidInput { reason, .. } | SolidError::PortInvariant { reason, .. } if *reason == NULL_DEREF) => {
                             Err(e)
                         }
                         Err(e) => Ok(vec![model_status(&e)]),
@@ -1898,7 +1898,7 @@ fn corner_err(e: &SolidError) -> Result<f64, Box<Output>> {
     if let Some(o) = Output::unported(e) {
         return Err(Box::new(o));
     }
-    if matches!(e, SolidError::InvalidInput { reason, .. } if *reason == NULL_DEREF) {
+    if matches!(e, SolidError::InvalidInput { reason, .. } | SolidError::PortInvariant { reason, .. } if *reason == NULL_DEREF) {
         return Err(Box::new(Output::err("refused")));
     }
     Ok(model_status(e))

crates/difftest/src/units/blend_fillet_corner_p2.rs

@@ -539,7 +539,7 @@ fn run_rust(i: &Inputs) -> Result<Output, HarnessError> {
         // every InvalidInput of the op is a null dereference upstream (the empty list is
         // screened above): a missing radial (`NULL_DEREF`) or, from unit
         // `topology.edgeuse_p1`, a missing edge; the shim refuses both
-        Err(SolidError::InvalidInput { .. }) => Ok(Output::err("refused")),
+        Err(SolidError::InvalidInput { .. } | SolidError::PortInvariant { .. }) => Ok(Output::err("refused")),
         Err(e) => Ok(rust_err(&e)),
     }
 }

crates/difftest/src/units/blend_fillet_custom_solver.rs

@@ -459,7 +459,7 @@ fn surface_of(s: &InlineSrf) -> Result<Surface, HarnessError> {
 /// The `SmStatus` of a Rust error; `-1` for one upstream cannot return.
 fn status(e: &SolidError) -> f64 {
     match e {
-        SolidError::InvalidInput { .. } => 1007.0,
+        SolidError::InvalidInput { .. } | SolidError::PortInvariant { .. } => 1007.0,
         SolidError::Upstream { code, .. } => f64::from(*code),
         _ => -1.0,
     }

crates/difftest/src/units/blend_fillet_executive_p3.rs

@@ -853,7 +853,7 @@ fn rust(input: &Inputs) -> Result<Output, HarnessError> {
                 return Ok(deferred);
             }
             match error {
-                SolidError::InvalidInput { .. } => 1007,
+                SolidError::InvalidInput { .. } | SolidError::PortInvariant { .. } => 1007,
                 SolidError::Upstream { code, .. } => code,
                 other => return Err(HarnessError::new(other.to_string())),
             }

crates/difftest/src/units/blend_fillet_executive_p3/end_to_end.rs

@@ -643,7 +643,7 @@ fn point(out: &mut Vec<f64>, p: Vec3) {
 }
 pub(super) fn status(error: SolidError) -> SolidResult<f64> {
     match error {
-        SolidError::InvalidInput { .. } => Ok(1007.0),
+        SolidError::InvalidInput { .. } | SolidError::PortInvariant { .. } => Ok(1007.0),
         SolidError::Upstream { code, .. } => Ok(f64::from(code)),
         error => Err(error),
     }
@@ -892,7 +892,7 @@ fn setback_fillet_edges(
     }
     // SmApiSetBevelCorners ignores the ordinary StitchAndOrient return status.
     match stitch_and_orient(k, body, &StitchAndOrientOptions::default()) {
-        Ok(()) | Err(SolidError::Upstream { .. } | SolidError::InvalidInput { .. }) => Ok(()),
+        Ok(()) | Err(SolidError::Upstream { .. } | SolidError::InvalidInput { .. } | SolidError::PortInvariant { .. }) => Ok(()),
         Err(error) => Err(error.into()),
     }
 }
@@ -987,7 +987,7 @@ fn law_fillet_edges(
         session.do_fillet(k)?;
     }
     match stitch_and_orient(k, body, &StitchAndOrientOptions::default()) {
-        Ok(()) | Err(SolidError::Upstream { .. } | SolidError::InvalidInput { .. }) => Ok(()),
+        Ok(()) | Err(SolidError::Upstream { .. } | SolidError::InvalidInput { .. } | SolidError::PortInvariant { .. }) => Ok(()),
         Err(error) => Err(error),
     }
 }

crates/difftest/src/units/blend_fillet_geom_p1.rs

@@ -1181,7 +1181,7 @@ fn uv(p: [f64; 2]) -> Point2 {
 /// The `SmStatus` of a Rust error; `-1` for one upstream cannot return.
 pub(crate) fn status(e: &SolidError) -> f64 {
     match e {
-        SolidError::InvalidInput { .. } => 1007.0,
+        SolidError::InvalidInput { .. } | SolidError::PortInvariant { .. } => 1007.0,
         SolidError::Upstream { code, .. } => f64::from(*code),
         _ => -1.0,
     }

crates/difftest/src/units/blend_fillet_geom_p3.rs

@@ -971,7 +971,7 @@ fn dump_curve(o: &mut Vec<f64>, c: Option<&Curve>) {
 /// The `SmStatus` of a Rust error; `-1` for one upstream cannot return.
 fn status(e: &SolidError) -> f64 {
     match e {
-        SolidError::InvalidInput { .. } => 1007.0,
+        SolidError::InvalidInput { .. } | SolidError::PortInvariant { .. } => 1007.0,
         SolidError::Upstream { code, .. } => f64::from(*code),
         _ => -1.0,
     }

crates/difftest/src/units/blend_fillet_geom_p6.rs

@@ -1410,7 +1410,7 @@ fn dump_surface(o: &mut Vec<f64>, s: Option<&Surface>) -> Result<(), HarnessErro
 /// The `SmStatus` of a Rust error; `-1` for one upstream cannot return.
 fn status(e: &SolidError) -> f64 {
     match e {
-        SolidError::InvalidInput { .. } => 1007.0,
+        SolidError::InvalidInput { .. } | SolidError::PortInvariant { .. } => 1007.0,
         SolidError::Upstream { code, .. } => f64::from(*code),
         _ => -1.0,
     }

crates/difftest/src/units/blend_fillet_intersector.rs

@@ -357,7 +357,7 @@ impl From<HarnessError> for Fail {
 /// cannot return.
 fn status(e: &SolidError) -> f64 {
     match e {
-        SolidError::InvalidInput { .. } => 1007.0,
+        SolidError::InvalidInput { .. } | SolidError::PortInvariant { .. } => 1007.0,
         SolidError::Upstream { code, .. } => f64::from(*code),
         _ => -1.0,
     }

crates/difftest/src/units/blend_fillet_solver_p1.rs

@@ -656,7 +656,7 @@ fn cpp(i: &Inputs) -> Result<Output, HarnessError> {
 
 fn status(e: &SolidError) -> f64 {
     match e {
-        SolidError::InvalidInput { .. } => 1007.0,
+        SolidError::InvalidInput { .. } | SolidError::PortInvariant { .. } => 1007.0,
         SolidError::Upstream { code, .. } => f64::from(*code),
         _ => -1.0,
     }
@@ -959,7 +959,7 @@ fn rust_brep(
                     put_crv(&k, o, copy.as_ref().or(edge_curve));
                     Ok(())
                 }
-                Err(SolidError::InvalidInput { .. }) => {
+                Err(SolidError::InvalidInput { .. } | SolidError::PortInvariant { .. }) => {
                     o.push(-2.0);
                     Ok(())
                 }
@@ -1031,7 +1031,7 @@ fn rust_brep(
             let side = EdgeuseId::from_index(eid(r[3])?);
             let one = |res: Result<usize, SolidError>| match res {
                 Ok(v) => Ok(v as f64),
-                Err(SolidError::InvalidInput { .. }) => Ok(-2.0),
+                Err(SolidError::InvalidInput { .. } | SolidError::PortInvariant { .. }) => Ok(-2.0),
                 Err(e) => Err(e),
             };
             (|| -> Result<(), SolidError> {
@@ -1051,7 +1051,7 @@ fn rust_brep(
                     o.extend([b(tangent), b(opposite)]);
                     Ok(())
                 }
-                Err(SolidError::InvalidInput { .. }) => {
+                Err(SolidError::InvalidInput { .. } | SolidError::PortInvariant { .. }) => {
                     o.push(-2.0);
                     Ok(())
                 }

crates/difftest/src/units/blend_fillet_solver_p2.rs

@@ -464,7 +464,7 @@ fn cpp(i: &Inputs) -> Result<Output, HarnessError> {
 
 fn status(e: &SolidError) -> f64 {
     match e {
-        SolidError::InvalidInput { .. } => 1007.0,
+        SolidError::InvalidInput { .. } | SolidError::PortInvariant { .. } => 1007.0,
         SolidError::Upstream { code, .. } => f64::from(*code),
         _ => -1.0,
     }

crates/difftest/src/units/blend_fillet_solver_p3.rs

@@ -275,7 +275,7 @@ impl FilletSolverOps for HarnessSolver {
 
 fn status(e: &SolidError) -> f64 {
     match e {
-        SolidError::InvalidInput { .. } => 1007.0,
+        SolidError::InvalidInput { .. } | SolidError::PortInvariant { .. } => 1007.0,
         SolidError::Upstream { code, .. } => f64::from(*code),
         _ => -1.0,
     }

crates/difftest/src/units/blend_fillet_solver_p4.rs

@@ -368,7 +368,7 @@ fn setup<T>(r: solidcore::Result<T>, what: &str) -> Result<T, Fail> {
 /// cannot return.
 fn status(e: &SolidError) -> i64 {
     match e {
-        SolidError::InvalidInput { .. } => 1007,
+        SolidError::InvalidInput { .. } | SolidError::PortInvariant { .. } => 1007,
         SolidError::Upstream { code, .. } => i64::from(*code),
         _ => -1,
     }

crates/difftest/src/units/blend_fillet_standard_solver_p2.rs

@@ -735,7 +735,7 @@ fn rust_edgeuse(i: &Inputs) -> Result<Output, HarnessError> {
                 return Ok(o);
             }
             match e {
-                SolidError::InvalidInput { .. } => Ok(Output::err("null_deref")),
+                SolidError::InvalidInput { .. } | SolidError::PortInvariant { .. } => Ok(Output::err("null_deref")),
                 e => Err(harness(format!("rust: {e}"))),
             }
         }
@@ -1041,7 +1041,7 @@ fn surface_of(s: &SrfIn) -> Result<Surface, HarnessError> {
 /// The `SmStatus` of a Rust error; `-1` for one upstream cannot return.
 fn status(e: &SolidError) -> f64 {
     match e {
-        SolidError::InvalidInput { .. } => 1007.0,
+        SolidError::InvalidInput { .. } | SolidError::PortInvariant { .. } => 1007.0,
         SolidError::Upstream { code, .. } => f64::from(*code),
         _ => -1.0,
     }

crates/difftest/src/units/blend_hcr.rs

@@ -659,7 +659,7 @@ fn run_rust(k: &Kernel, mut h: Hcr, r: &Resolved) -> Result<(f64, Vec<f64>), Sol
             };
             match res {
                 Ok(()) => {}
-                Err(e) if e.is_unported() || matches!(e, SolidError::InvalidInput { .. }) => return Err(e),
+                Err(e) if e.is_unported() || matches!(e, SolidError::InvalidInput { .. } | SolidError::PortInvariant { .. }) => return Err(e),
                 Err(SolidError::Upstream { code, .. }) => status = f64::from(code),
                 Err(e) => return Err(e),
             }

crates/difftest/src/units/boolean_api_brep.rs

@@ -422,7 +422,7 @@ fn ub_242(i: &Inputs) -> Result<bool, HarnessError> {
 /// The `SmStatus` of a Rust error; `-1` for one upstream cannot return.
 fn status(e: &SolidError) -> i64 {
     match e {
-        SolidError::InvalidInput { .. } => SM_ERR_INVALID_INPUT,
+        SolidError::InvalidInput { .. } | SolidError::PortInvariant { .. } => SM_ERR_INVALID_INPUT,
         SolidError::Upstream { code, .. } => i64::from(*code),
         _ => -1,
     }
@@ -759,7 +759,7 @@ fn rust_call_with(k: &mut Kernel, i: &Inputs, seen: &dyn Fn(&SolidError)) -> Res
                     Ok(record(0, o))
                 }
                 // Rejected: no result (`cleared`) and the list untouched.
-                Err(e) if matches!(e, SolidError::InvalidInput { .. }) => {
+                Err(e) if matches!(e, SolidError::InvalidInput { .. } | SolidError::PortInvariant { .. }) => {
                     seen(&e);
                     Ok(record(status(&e), vec![1, count(v.len())?]))
                 }

crates/difftest/src/units/boolean_merge_p2.rs

@@ -258,7 +258,7 @@ fn output(raw: &[f64]) -> Result<Output, HarnessError> {
 fn status(e: &SolidError) -> i64 {
     match e {
         SolidError::Upstream { code, .. } => i64::from(*code),
-        SolidError::InvalidInput { .. } => 1007,
+        SolidError::InvalidInput { .. } | SolidError::PortInvariant { .. } => 1007,
         _ => -1,
     }
 }

crates/difftest/src/units/boolean_merge_p3.rs

@@ -240,7 +240,7 @@ fn options(mask: u8) -> MergeOptions {
 }
 fn status(error: &SolidError) -> i64 {
     match error {
-        SolidError::InvalidInput { .. } => 1007,
+        SolidError::InvalidInput { .. } | SolidError::PortInvariant { .. } => 1007,
         SolidError::Upstream { code, .. } => i64::from(*code),
         _ => -1,
     }

crates/difftest/src/units/boolean_topology_intersector_p1.rs

@@ -3579,7 +3579,7 @@ fn status<T>(r: Result<T, SolidError>, o: &mut Vec<f64>) -> Result<Option<T>, Fa
             o.push(f64::from(code));
             Ok(None)
         }
-        Err(SolidError::InvalidInput { .. }) => {
+        Err(SolidError::InvalidInput { .. } | SolidError::PortInvariant { .. }) => {
             o.push(NULL_DEREF);
             Ok(None)
         }
@@ -3868,7 +3868,7 @@ fn run_rust_script(i: &Inputs, p: Prepared) -> Result<(Vec<f64>, Vec<usize>), Fa
                 }
                 match ti::find_first_lowest_dimension_sol(&sols) {
                     Ok(idx) => o.push(idx as f64),
-                    Err(SolidError::InvalidInput { .. }) => o.push(NULL_DEREF),
+                    Err(SolidError::InvalidInput { .. } | SolidError::PortInvariant { .. }) => o.push(NULL_DEREF),
                     Err(e) => return Err(e.into()),
                 }
             }
@@ -4294,7 +4294,7 @@ fn run_part2_op(
                 // (without the maps, a definition with both finals is the port's
                 // InvalidInput, which the shim refuses with -2 alone)
                 let r = ti.set_relationships(k, two);
-                if matches!(r, Err(SolidError::InvalidInput { .. })) {
+                if matches!(r, Err(SolidError::InvalidInput { .. } | SolidError::PortInvariant { .. })) {
                     o.push(NULL_DEREF);
                     return Ok(());
                 }

crates/difftest/src/units/boolean_topology_intersector_p3.rs

@@ -510,7 +510,7 @@ fn status<T>(r: Result<T, SolidError>, o: &mut Vec<f64>) -> Result<Option<T>, So
             o.push(f64::from(code));
             Ok(None)
         }
-        Err(SolidError::InvalidInput { .. }) => {
+        Err(SolidError::InvalidInput { .. } | SolidError::PortInvariant { .. }) => {
             o.push(NULL_DEREF);
             Ok(None)
         }

crates/difftest/src/units/curve_composite_curve_p1.rs

@@ -559,7 +559,7 @@ fn pv(o: &mut Vec<f64>, v: Vec3) {
 /// cannot return.
 fn status(e: &SolidError) -> f64 {
     match e {
-        SolidError::InvalidInput { .. } => 1007.0,
+        SolidError::InvalidInput { .. } | SolidError::PortInvariant { .. } => 1007.0,
         SolidError::Upstream { code, .. } => f64::from(*code),
         _ => -1.0,
     }

crates/difftest/src/units/curve_composite_curve_p2.rs

@@ -636,7 +636,7 @@ fn pv(o: &mut Vec<f64>, v: Vec3) {
 /// cannot return.
 fn status(e: &SolidError) -> f64 {
     match e {
-        SolidError::InvalidInput { .. } => 1007.0,
+        SolidError::InvalidInput { .. } | SolidError::PortInvariant { .. } => 1007.0,
         SolidError::Upstream { code, .. } => f64::from(*code),
         _ => -1.0,
     }

crates/difftest/src/units/curve_conic.rs

@@ -103,7 +103,7 @@ fn lookup(name: &str) -> Result<(Op, bool), HarnessError> {
 
 fn status_code(e: &SolidError) -> i64 {
     match e {
-        SolidError::InvalidInput { .. } => i64::from(SM_ERR_INVALID_INPUT),
+        SolidError::InvalidInput { .. } | SolidError::PortInvariant { .. } => i64::from(SM_ERR_INVALID_INPUT),
         SolidError::Upstream { code, .. } => i64::from(*code),
         _ => -1,
     }

crates/difftest/src/units/curve_crv_in_volume.rs

@@ -571,7 +571,7 @@ fn put_state(o: &mut Vec<f64>, c: &CrvInVolume) {
 /// cannot return.
 fn status(e: &SolidError) -> f64 {
     match e {
-        SolidError::InvalidInput { .. } => 1007.0,
+        SolidError::InvalidInput { .. } | SolidError::PortInvariant { .. } => 1007.0,
         SolidError::Upstream { code, .. } => f64::from(*code),
         _ => -1.0,
     }

crates/difftest/src/units/curve_crv_on_surf.rs

@@ -674,7 +674,7 @@ fn put_state(o: &mut Vec<f64>, c: &CrvOnSurf) {
 /// cannot return.
 fn status(e: &SolidError) -> f64 {
     match e {
-        SolidError::InvalidInput { .. } => 1007.0,
+        SolidError::InvalidInput { .. } | SolidError::PortInvariant { .. } => 1007.0,
         SolidError::Upstream { code, .. } => f64::from(*code),
         _ => -1.0,
     }

crates/difftest/src/units/curve_curve_cache.rs

@@ -262,7 +262,7 @@ fn build(c: &CurveIn) -> Result<Curve, HarnessError> {
 /// cannot return.
 fn status(e: &SolidError) -> f64 {
     match e {
-        SolidError::InvalidInput { .. } => 1007.0,
+        SolidError::InvalidInput { .. } | SolidError::PortInvariant { .. } => 1007.0,
         SolidError::Upstream { code, .. } => f64::from(*code),
         _ => -1.0,
     }

crates/difftest/src/units/curve_curve_p1.rs

@@ -307,7 +307,7 @@ fn pv(o: &mut Vec<f64>, v: Vec3) {
 /// cannot return.
 fn status(e: &SolidError) -> f64 {
     match e {
-        SolidError::InvalidInput { .. } => 1007.0,
+        SolidError::InvalidInput { .. } | SolidError::PortInvariant { .. } => 1007.0,
         SolidError::Upstream { code, .. } => f64::from(*code),
         _ => -1.0,
     }

crates/difftest/src/units/curve_curve_p2.rs

@@ -750,7 +750,7 @@ fn state(o: &mut Vec<f64>, c: &Curve) {
 /// cannot return.
 fn status(e: &SolidError) -> f64 {
     match e {
-        SolidError::InvalidInput { .. } => 1007.0,
+        SolidError::InvalidInput { .. } | SolidError::PortInvariant { .. } => 1007.0,
         SolidError::Upstream { code, .. } => f64::from(*code),
         _ => -1.0,
     }

crates/difftest/src/units/curve_curve_p3.rs

@@ -508,7 +508,7 @@ fn pv(o: &mut Vec<f64>, v: Vec3) {
 /// cannot return.
 fn status(e: &SolidError) -> f64 {
     match e {
-        SolidError::InvalidInput { .. } => 1007.0,
+        SolidError::InvalidInput { .. } | SolidError::PortInvariant { .. } => 1007.0,
         SolidError::Upstream { code, .. } => f64::from(*code),
         _ => -1.0,
     }

crates/difftest/src/units/curve_curve_p4.rs

@@ -609,7 +609,7 @@ fn pv(o: &mut Vec<f64>, v: Vec3) {
 /// cannot return.
 fn status(e: &SolidError) -> f64 {
     match e {
-        SolidError::InvalidInput { .. } => 1007.0,
+        SolidError::InvalidInput { .. } | SolidError::PortInvariant { .. } => 1007.0,
         SolidError::Upstream { code, .. } => f64::from(*code),
         _ => -1.0,
     }

crates/difftest/src/units/curve_curve_p5.rs

@@ -619,7 +619,7 @@ fn pv(o: &mut Vec<f64>, v: Vec3) {
 /// cannot return.
 fn status(e: &SolidError) -> f64 {
     match e {
-        SolidError::InvalidInput { .. } => 1007.0,
+        SolidError::InvalidInput { .. } | SolidError::PortInvariant { .. } => 1007.0,
         SolidError::Upstream { code, .. } => f64::from(*code),
         _ => -1.0,
     }

crates/difftest/src/units/curve_curve_p6.rs

@@ -481,7 +481,7 @@ fn pv(o: &mut Vec<f64>, v: Vec3) {
 /// cannot return.
 fn status(e: &SolidError) -> f64 {
     match e {
-        SolidError::InvalidInput { .. } => 1007.0,
+        SolidError::InvalidInput { .. } | SolidError::PortInvariant { .. } => 1007.0,
         SolidError::Upstream { code, .. } => f64::from(*code),
         _ => -1.0,
     }

crates/difftest/src/units/curve_curve_p7.rs

@@ -434,7 +434,7 @@ fn build(c: &CurveIn) -> Result<Curve, HarnessError> {
 /// cannot return.
 fn status(e: &SolidError) -> f64 {
     match e {
-        SolidError::InvalidInput { .. } => 1007.0,
+        SolidError::InvalidInput { .. } | SolidError::PortInvariant { .. } => 1007.0,
         SolidError::Upstream { code, .. } => f64::from(*code),
         _ => -1.0,
     }

crates/difftest/src/units/curve_curve_p8.rs

@@ -294,7 +294,7 @@ fn build(c: &CurveIn) -> Result<Curve, HarnessError> {
 /// cannot return.
 fn status(e: &SolidError) -> f64 {
     match e {
-        SolidError::InvalidInput { .. } => 1007.0,
+        SolidError::InvalidInput { .. } | SolidError::PortInvariant { .. } => 1007.0,
         SolidError::Upstream { code, .. } => f64::from(*code),
         _ => -1.0,
     }

crates/difftest/src/units/curve_curve_p9.rs

@@ -297,7 +297,7 @@ fn build(c: &CurveIn) -> Result<Curve, HarnessError> {
 /// cannot return.
 fn status(e: &SolidError) -> f64 {
     match e {
-        SolidError::InvalidInput { .. } => 1007.0,
+        SolidError::InvalidInput { .. } | SolidError::PortInvariant { .. } => 1007.0,
         SolidError::Upstream { code, .. } => f64::from(*code),
         _ => -1.0,
     }

crates/difftest/src/units/curve_ellipse_p1.rs

@@ -494,7 +494,7 @@ fn b(x: bool) -> f64 {
 /// cannot return.
 fn status(e: &SolidError) -> f64 {
     match e {
-        SolidError::InvalidInput { .. } => 1007.0,
+        SolidError::InvalidInput { .. } | SolidError::PortInvariant { .. } => 1007.0,
         SolidError::Upstream { code, .. } => f64::from(*code),
         _ => -1.0,
     }
@@ -1114,7 +1114,7 @@ fn reads_uninitialised(i: &Inputs) -> bool {
     for op in &i.ops {
         if let OpJ::Assert { given } = op {
             let mut list = AssertArray::new();
-            if let Err(SolidError::InvalidInput { reason, .. }) =
+            if let Err(SolidError::InvalidInput { reason, .. } | SolidError::PortInvariant { reason, .. }) =
                 a.assert_valid(&k, Some(&mut list), *given, KEY_A, KEY_POLAR)
             {
                 if reason.contains("uninitialised") {

crates/difftest/src/units/curve_ellipse_p2.rs

@@ -314,7 +314,7 @@ fn b(x: bool) -> f64 {
 /// cannot return.
 fn status(e: &SolidError) -> f64 {
     match e {
-        SolidError::InvalidInput { .. } => 1007.0,
+        SolidError::InvalidInput { .. } | SolidError::PortInvariant { .. } => 1007.0,
         SolidError::Upstream { code, .. } => f64::from(*code),
         _ => -1.0,
     }

crates/difftest/src/units/curve_hermite_curve.rs

@@ -144,7 +144,7 @@ fn lookup<T: Copy>(table: &[(&str, T)], name: &str) -> Result<T, HarnessError> {
 
 fn status_code(e: &SolidError) -> f64 {
     match e {
-        SolidError::InvalidInput { .. } => f64::from(SM_ERR_INVALID_INPUT),
+        SolidError::InvalidInput { .. } | SolidError::PortInvariant { .. } => f64::from(SM_ERR_INVALID_INPUT),
         SolidError::Upstream { code, .. } => f64::from(*code),
         _ => -1.0,
     }

crates/difftest/src/units/curve_hyperbola.rs

@@ -255,7 +255,7 @@ fn pv(o: &mut Vec<f64>, v: Vec3) {
 
 fn status_code(e: &SolidError) -> f64 {
     match e {
-        SolidError::InvalidInput { .. } => SM_ERR_INVALID_INPUT,
+        SolidError::InvalidInput { .. } | SolidError::PortInvariant { .. } => SM_ERR_INVALID_INPUT,
         SolidError::Upstream { code, .. } => f64::from(*code),
         _ => -1.0,
     }

crates/difftest/src/units/curve_iso_curve.rs

@@ -427,7 +427,7 @@ fn state(o: &mut Vec<f64>, c: &Curve) -> Result<(), HarnessError> {
 /// The `SmStatus` of a Rust error; `-1` for one upstream cannot return.
 fn status(e: &SolidError) -> f64 {
     match e {
-        SolidError::InvalidInput { .. } => 1007.0,
+        SolidError::InvalidInput { .. } | SolidError::PortInvariant { .. } => 1007.0,
         SolidError::Upstream { code, .. } => f64::from(*code),
         _ => -1.0,
     }

crates/difftest/src/units/curve_line.rs

@@ -591,7 +591,7 @@ fn b(x: bool) -> f64 {
 /// cannot return.
 fn status(e: &SolidError) -> f64 {
     match e {
-        SolidError::InvalidInput { .. } => 1007.0,
+        SolidError::InvalidInput { .. } | SolidError::PortInvariant { .. } => 1007.0,
         SolidError::Upstream { code, .. } => f64::from(*code),
         _ => -1.0,
     }

crates/difftest/src/units/curve_offset_curve.rs

@@ -472,7 +472,7 @@ fn clone_ctor_unsafe(i: &Inputs) -> bool {
 /// cannot return.
 fn status(e: &SolidError) -> f64 {
     match e {
-        SolidError::InvalidInput { .. } => 1007.0,
+        SolidError::InvalidInput { .. } | SolidError::PortInvariant { .. } => 1007.0,
         SolidError::Upstream { code, .. } => f64::from(*code),
         _ => -1.0,
     }

crates/difftest/src/units/curve_parabola.rs

@@ -125,7 +125,7 @@ fn harness(msg: &str) -> HarnessError {
 
 fn status_code(e: &SolidError) -> f64 {
     match e {
-        SolidError::InvalidInput { .. } => SM_ERR_INVALID_INPUT,
+        SolidError::InvalidInput { .. } | SolidError::PortInvariant { .. } => SM_ERR_INVALID_INPUT,
         SolidError::Upstream { code, .. } => f64::from(*code),
         _ => -1.0,
     }

crates/difftest/src/units/curve_projected_curve.rs

@@ -638,7 +638,7 @@ fn state(o: &mut Vec<f64>, c: &ProjectedCurve) {
 /// cannot return.
 fn status(e: &SolidError) -> f64 {
     match e {
-        SolidError::InvalidInput { .. } => 1007.0,
+        SolidError::InvalidInput { .. } | SolidError::PortInvariant { .. } => 1007.0,
         SolidError::Upstream { code, .. } => f64::from(*code),
         _ => -1.0,
     }

crates/difftest/src/units/curve_tangent_field.rs

@@ -503,7 +503,7 @@ fn domain(d: Option<[f64; 4]>) -> Result<Option<Extent2d>, HarnessError> {
 /// cannot return.
 fn status(e: &SolidError) -> i64 {
     match e {
-        SolidError::InvalidInput { .. } => 1007,
+        SolidError::InvalidInput { .. } | SolidError::PortInvariant { .. } => 1007,
         SolidError::Upstream { code, .. } => i64::from(*code),
         _ => -1,
     }

crates/difftest/src/units/geom_assert_array.rs

@@ -134,7 +134,7 @@ fn key_int(k: Option<ObjectKey>) -> i64 {
 
 fn normalise(e: &SolidError) -> String {
     match e {
-        SolidError::InvalidInput { .. } => "invalid_input".into(),
+        SolidError::InvalidInput { .. } | SolidError::PortInvariant { .. } => "invalid_input".into(),
         SolidError::Upstream { code, .. } => format!("status_{code}"),
         other => format!("rust_error: {other}"),
     }

crates/difftest/src/units/geom_axis2_placement.rs

@@ -114,7 +114,7 @@ fn lookup<T: Copy>(table: &[(&str, T)], name: &str) -> Result<T, HarnessError> {
 
 fn status_code(e: &SolidError) -> f64 {
     match e {
-        SolidError::InvalidInput { .. } => f64::from(SM_ERR_INVALID_INPUT),
+        SolidError::InvalidInput { .. } | SolidError::PortInvariant { .. } => f64::from(SM_ERR_INVALID_INPUT),
         SolidError::Upstream { code, .. } => f64::from(*code),
         _ => -1.0,
     }

crates/difftest/src/units/geom_extent1d.rs

@@ -127,7 +127,7 @@ fn e2(e: &Extent1d) -> E2 {
 /// Status value of a Rust error (upstream `SmStatus`).
 fn status_of(e: &SolidError) -> Result<f64, HarnessError> {
     match e {
-        SolidError::InvalidInput { .. } => Ok(1007.0),
+        SolidError::InvalidInput { .. } | SolidError::PortInvariant { .. } => Ok(1007.0),
         SolidError::Upstream { code, .. } => Ok(f64::from(*code)),
         other => Err(harness(format!("unexpected rust error: {other}"))),
     }

crates/difftest/src/units/geom_extent2d.rs

@@ -293,7 +293,7 @@ fn b(v: bool) -> f64 {
 /// Status value of a Rust error (upstream `SmStatus`).
 fn status_of(e: &SolidError) -> Result<f64, HarnessError> {
     match e {
-        SolidError::InvalidInput { .. } => Ok(1007.0),
+        SolidError::InvalidInput { .. } | SolidError::PortInvariant { .. } => Ok(1007.0),
         SolidError::Upstream { code, .. } => Ok(f64::from(*code)),
         other => Err(harness(format!("unexpected rust error: {other}"))),
     }

crates/difftest/src/units/geom_extent3d.rs

@@ -287,7 +287,7 @@ fn b(v: bool) -> f64 {
 /// Status value of a Rust error (upstream `SmStatus`).
 fn status_of(e: &SolidError) -> Result<f64, HarnessError> {
     match e {
-        SolidError::InvalidInput { .. } => Ok(1007.0),
+        SolidError::InvalidInput { .. } | SolidError::PortInvariant { .. } => Ok(1007.0),
         SolidError::Upstream { code, .. } => Ok(f64::from(*code)),
         other => Err(harness(format!("unexpected rust error: {other}"))),
     }

crates/difftest/src/units/geom_geom_utility_p1.rs

@@ -116,7 +116,7 @@ fn lookup(name: &str) -> Result<Op, HarnessError> {
 /// Upstream status of a Rust error, or `None` for errors with no upstream status.
 fn status_code(e: &SolidError) -> Option<f64> {
     match e {
-        SolidError::InvalidInput { .. } => Some(1007.0),
+        SolidError::InvalidInput { .. } | SolidError::PortInvariant { .. } => Some(1007.0),
         SolidError::Upstream { code, .. } => Some(f64::from(*code)),
         _ => None,
     }

crates/difftest/src/units/geom_geom_utility_p2.rs

@@ -75,7 +75,7 @@ fn status(code: i32) -> Output {
 
 fn normalise(e: &SolidError) -> String {
     match e {
-        SolidError::InvalidInput { .. } => "status_1007".into(),
+        SolidError::InvalidInput { .. } | SolidError::PortInvariant { .. } => "status_1007".into(),
         SolidError::Upstream { code, .. } => format!("status_{code}"),
         other => format!("rust_error: {other}"),
     }

crates/difftest/src/units/geom_grid/tests.rs

@@ -111,7 +111,7 @@ fn explicit_definition_does_not_resolve_an_opaque_label() {
     ];
     assert!(matches!(
         run_rust(&i, &mut Stats::default()),
-        Err(SolidError::InvalidInput { .. })
+        Err(SolidError::InvalidInput { .. } | SolidError::PortInvariant { .. })
     ));
 }
 

crates/difftest/src/units/geom_local_solve_nd.rs

@@ -599,7 +599,7 @@ fn rust(p: &Parsed) -> Result<Output, HarnessError> {
         Err(e) => Ok(Output::unported(&e).unwrap_or_else(|| {
             Output::err(match e {
                 SolidError::Upstream { code, .. } => format!("status_{code}"),
-                SolidError::InvalidInput { .. } => "status_1007".into(),
+                SolidError::InvalidInput { .. } | SolidError::PortInvariant { .. } => "status_1007".into(),
                 other => format!("rust_error: {other}"),
             })
         })),

crates/difftest/src/units/geom_matrix.rs

@@ -91,7 +91,7 @@ fn floats(v: &[Value]) -> Result<Vec<f64>, HarnessError> {
 
 fn normalise(e: &SolidError) -> String {
     match e {
-        SolidError::InvalidInput { .. } => "status_1007".into(),
+        SolidError::InvalidInput { .. } | SolidError::PortInvariant { .. } => "status_1007".into(),
         SolidError::Upstream { code, .. } => format!("status_{code}"),
         other => format!("rust_error: {other}"),
     }

crates/difftest/src/units/geom_periodic_extent1d.rs

@@ -123,7 +123,7 @@ fn status_of(r: &solidcore::Result<()>) -> Result<i64, HarnessError> {
     match r {
         Ok(()) => Ok(SM_SUCCESS),
         Err(SolidError::Upstream { code, .. }) => Ok(i64::from(*code)),
-        Err(SolidError::InvalidInput { .. }) => Ok(SM_ERR_INVALID_INPUT),
+        Err(SolidError::InvalidInput { .. } | SolidError::PortInvariant { .. }) => Ok(SM_ERR_INVALID_INPUT),
         Err(e) => Err(HarnessError::new(format!("rust_error: {e}"))),
     }
 }

crates/difftest/src/units/geom_transform.rs

@@ -139,7 +139,7 @@ fn lookup<T: Copy>(table: &[(&str, T)], name: &str) -> Result<T, HarnessError> {
 
 fn status_code(e: &SolidError) -> f64 {
     match e {
-        SolidError::InvalidInput { .. } => f64::from(SM_ERR_INVALID_INPUT),
+        SolidError::InvalidInput { .. } | SolidError::PortInvariant { .. } => f64::from(SM_ERR_INVALID_INPUT),
         SolidError::Upstream { code, .. } => f64::from(*code),
         _ => -1.0,
     }

crates/difftest/src/units/geom_tree.rs

@@ -291,7 +291,7 @@ fn flag(b: bool) -> i64 {
 /// Upstream status of a Rust error.
 fn status_of(e: &SolidError) -> i64 {
     match e {
-        SolidError::InvalidInput { .. } => 1007,
+        SolidError::InvalidInput { .. } | SolidError::PortInvariant { .. } => 1007,
         SolidError::Upstream { code, .. } => i64::from(*code),
         _ => 1001,
     }

crates/difftest/src/units/geom_vector2d.rs

@@ -88,7 +88,7 @@ fn lookup(name: &str) -> Result<Op, HarnessError> {
 
 fn normalise(e: &SolidError) -> String {
     match e {
-        SolidError::InvalidInput { .. } => "invalid_input".into(),
+        SolidError::InvalidInput { .. } | SolidError::PortInvariant { .. } => "invalid_input".into(),
         SolidError::Upstream { code, .. } => format!("status_{code}"),
         other => format!("rust_error: {other}"),
     }

crates/difftest/src/units/geom_vector3d.rs

@@ -134,7 +134,7 @@ fn lookup(name: &str) -> Result<Op, HarnessError> {
 
 fn normalise(e: &SolidError) -> String {
     match e {
-        SolidError::InvalidInput { .. } => "invalid_input".into(),
+        SolidError::InvalidInput { .. } | SolidError::PortInvariant { .. } => "invalid_input".into(),
         SolidError::Upstream { code, .. } => format!("status_{code}"),
         other => format!("rust_error: {other}"),
     }

crates/difftest/src/units/heal_gap.rs

@@ -1174,7 +1174,7 @@ fn run_rust(i: &Inputs) -> Result<Output, HarnessError> {
             let args = topo_args(&b, c, *kind, *sel0, *sel1, *f0, *f1, *uv)?;
             match topo_rust(&k, &mut b, &args) {
                 Ok(v) => o = v,
-                Err(SolidError::InvalidInput { .. }) => o.push(NULL_DEREF),
+                Err(SolidError::InvalidInput { .. } | SolidError::PortInvariant { .. }) => o.push(NULL_DEREF),
                 Err(e) => return rust_fail(&e),
             }
         }

crates/difftest/src/units/heal_heal_data_p1.rs

@@ -138,7 +138,7 @@ fn run_rust(i: &Inputs) -> Result<Output, HarnessError> {
                             create_status = SM_SUCCESS;
                             api_heal_brep(&mut k, Some(&mut b))
                         }
-                        Err(SolidError::InvalidInput { .. }) => {
+                        Err(SolidError::InvalidInput { .. } | SolidError::PortInvariant { .. }) => {
                             return Ok(Output::new().values("out", vec![SM_ERR_INVALID_INPUT, 0.0]));
                         }
                         Err(e) => {
@@ -150,7 +150,7 @@ fn run_rust(i: &Inputs) -> Result<Output, HarnessError> {
             };
             Ok(match r {
                 Ok(()) => Output::new().values("out", vec![create_status, SM_SUCCESS]),
-                Err(SolidError::InvalidInput { .. }) => {
+                Err(SolidError::InvalidInput { .. } | SolidError::PortInvariant { .. }) => {
                     Output::new().values("out", vec![create_status, SM_ERR_INVALID_INPUT])
                 }
                 Err(e) => Output::unported(&e).unwrap_or_else(|| Output::err(e.to_string())),

crates/difftest/src/units/heal_heal_data_p2.rs

@@ -824,7 +824,7 @@ fn rust_prob(kind: u8, n: u64, ops: &[[i64; 4]]) -> Result<Output, HarnessError>
                 let r = match kind {
                     1 => match pair.remove(&arena, p) {
                         Ok(r) => r,
-                        Err(SolidError::InvalidInput { .. }) => {
+                        Err(SolidError::InvalidInput { .. } | SolidError::PortInvariant { .. }) => {
                             o.push(NULL_DEREF);
                             stop = true;
                             continue;
@@ -966,7 +966,7 @@ fn classify(e: SolidError) -> Fail {
         return Fail::Deferred(o);
     }
     match e {
-        SolidError::InvalidInput { .. } => Fail::NullDeref,
+        SolidError::InvalidInput { .. } | SolidError::PortInvariant { .. } => Fail::NullDeref,
         SolidError::Upstream { code, .. } => Fail::Status(code),
         e => Fail::Other(e.to_string()),
     }

crates/difftest/src/units/heal_stitch_p1.rs

@@ -848,10 +848,10 @@ fn run_cpp(k: &Kernel, i: &Inputs) -> Result<Output, HarnessError> {
 fn status_of(e: &SolidError) -> f64 {
     match e {
         SolidError::Upstream { code, .. } => f64::from(*code),
-        SolidError::InvalidInput { operation, .. } if *operation == "heal::stitch::p1" => {
+        SolidError::InvalidInput { operation, .. } | SolidError::PortInvariant { operation, .. } if *operation == "heal::stitch::p1" => {
             NULL_DEREF
         }
-        SolidError::InvalidInput { .. } => SM_ERR_INVALID_INPUT,
+        SolidError::InvalidInput { .. } | SolidError::PortInvariant { .. } => SM_ERR_INVALID_INPUT,
         _ => -9.0,
     }
 }

crates/difftest/src/units/heal_stitch_p2.rs

@@ -482,12 +482,12 @@ fn run_cpp(i: &Inputs) -> Result<Output, HarnessError> {
 fn status_of(e: &SolidError) -> f64 {
     match e {
         SolidError::Upstream { code, .. } => f64::from(*code),
-        SolidError::InvalidInput { operation, .. }
+        SolidError::InvalidInput { operation, .. } | SolidError::PortInvariant { operation, .. }
             if *operation == "heal::stitch::p1" || *operation == "heal::stitch::p2" =>
         {
             NULL_DEREF
         }
-        SolidError::InvalidInput { .. } => SM_ERR_INVALID_INPUT,
+        SolidError::InvalidInput { .. } | SolidError::PortInvariant { .. } => SM_ERR_INVALID_INPUT,
         _ => -9.0,
     }
 }

crates/difftest/src/units/intersect_adv_surface_intersector.rs

@@ -321,7 +321,7 @@ impl From<HarnessError> for Fail {
 /// cannot return.
 fn status(e: &SolidError) -> f64 {
     match e {
-        SolidError::InvalidInput { .. } => 1007.0,
+        SolidError::InvalidInput { .. } | SolidError::PortInvariant { .. } => 1007.0,
         SolidError::Upstream { code, .. } => f64::from(*code),
         _ => -1.0,
     }
@@ -581,7 +581,7 @@ fn branch(a: usize, b: usize) -> [Option<NodeId>; MAX_SOLVER_TREES] {
 
 /// True for the error `ComputeSingularityPoint` returns on a ninth singular direction.
 fn is_sing_overflow(e: &SolidError) -> bool {
-    matches!(e, SolidError::InvalidInput { reason, .. } if reason.starts_with("more than 8 singular"))
+    matches!(e, SolidError::InvalidInput { reason, .. } | SolidError::PortInvariant { reason, .. } if reason.starts_with("more than 8 singular"))
 }
 
 struct Ctx<'a> {

crates/difftest/src/units/intersect_curve_class_p1.rs

@@ -1105,7 +1105,7 @@ pub(crate) fn build_pool(objects: &[ObjIn]) -> Result<Pool, HarnessError> {
 pub(crate) fn status(e: &SolidError) -> f64 {
     match e {
         SolidError::Upstream { code, .. } => f64::from(*code),
-        SolidError::InvalidInput { .. } => 1007.0,
+        SolidError::InvalidInput { .. } | SolidError::PortInvariant { .. } => 1007.0,
         _ => -1.0,
     }
 }

crates/difftest/src/units/intersect_curve_class_p3.rs

@@ -818,7 +818,7 @@ fn build_pool(objects: &[ObjIn]) -> Result<Pool, HarnessError> {
 fn status(e: &SolidError) -> f64 {
     match e {
         SolidError::Upstream { code, .. } => f64::from(*code),
-        SolidError::InvalidInput { .. } => 1007.0,
+        SolidError::InvalidInput { .. } | SolidError::PortInvariant { .. } => 1007.0,
         _ => -1.0,
     }
 }

crates/difftest/src/units/intersect_curve_class_p4.rs

@@ -907,7 +907,7 @@ pub(crate) fn face_brep(k: &Kernel, face: &FaceIn) -> Result<(Brep, FaceId), Har
 fn status(e: &SolidError) -> f64 {
     match e {
         SolidError::Upstream { code, .. } => f64::from(*code),
-        SolidError::InvalidInput { .. } => 1007.0,
+        SolidError::InvalidInput { .. } | SolidError::PortInvariant { .. } => 1007.0,
         _ => -1.0,
     }
 }

crates/difftest/src/units/intersect_curve_class_p5.rs

@@ -323,7 +323,7 @@ fn put_cc(out: &mut Vec<f64>, cc: &CurveClassification<H>, target: H) {
 fn status(e: &SolidError) -> f64 {
     match e {
         SolidError::Upstream { code, .. } => f64::from(*code),
-        SolidError::InvalidInput { .. } => 1007.,
+        SolidError::InvalidInput { .. } | SolidError::PortInvariant { .. } => 1007.,
         _ => -1.,
     }
 }

crates/difftest/src/units/intersect_curve_class_p6.rs

@@ -414,7 +414,7 @@ fn put_pc(out: &mut Vec<f64>, pc: &PointClassification<Handle>, g: &Geometry) {
 fn status(e: &SolidError) -> f64 {
     match e {
         SolidError::Upstream { code, .. } => f64::from(*code),
-        SolidError::InvalidInput { .. } => 1007.0,
+        SolidError::InvalidInput { .. } | SolidError::PortInvariant { .. } => 1007.0,
         _ => -1.0,
     }
 }

crates/difftest/src/units/intersect_ray_tracer.rs

@@ -457,7 +457,7 @@ fn build_poly(
 /// The status of a failed Rust operation, as upstream numbers it.
 fn status_of(e: &SolidError) -> f64 {
     match e {
-        SolidError::InvalidInput { .. } => 1007.0,
+        SolidError::InvalidInput { .. } | SolidError::PortInvariant { .. } => 1007.0,
         SolidError::Upstream { code, .. } => f64::from(*code),
         _ => 1001.0,
     }

crates/difftest/src/units/intersect_surface_drop_curve.rs

@@ -385,7 +385,7 @@ fn rust_curve(c: &CurveIn) -> Result<Curve, HarnessError> {
 /// cannot return.
 fn status(e: &SolidError) -> f64 {
     match e {
-        SolidError::InvalidInput { .. } => 1007.0,
+        SolidError::InvalidInput { .. } | SolidError::PortInvariant { .. } => 1007.0,
         SolidError::Upstream { code, .. } => f64::from(*code),
         _ => -1.0,
     }

crates/difftest/src/units/intersect_surface_drop_lib_p1.rs

@@ -681,7 +681,7 @@ fn put_uv_curve(o: &mut Vec<f64>, c: &Curve) -> Option<solidcore::Result<()>> {
 /// The `SmStatus` of a Rust error.
 fn status(e: &SolidError) -> f64 {
     match e {
-        SolidError::InvalidInput { .. } => 1007.0,
+        SolidError::InvalidInput { .. } | SolidError::PortInvariant { .. } => 1007.0,
         SolidError::Upstream { code, .. } => f64::from(*code),
         _ => 1001.0,
     }

crates/difftest/src/units/intersect_surface_drop_lib_p2.rs

@@ -564,7 +564,7 @@ pub(crate) fn put_curve(o: &mut Vec<f64>, c: &BSplineCurve) -> solidcore::Result
 /// The `SmStatus` of a Rust error.
 pub(crate) fn status(e: &SolidError) -> f64 {
     match e {
-        SolidError::InvalidInput { .. } => 1007.0,
+        SolidError::InvalidInput { .. } | SolidError::PortInvariant { .. } => 1007.0,
         SolidError::Upstream { code, .. } => f64::from(*code),
         _ => 1001.0,
     }

crates/difftest/src/units/intersect_surface_intersector_p1.rs

@@ -397,7 +397,7 @@ impl From<HarnessError> for Fail {
 /// cannot return.
 fn status(e: &SolidError) -> f64 {
     match e {
-        SolidError::InvalidInput { .. } => 1007.0,
+        SolidError::InvalidInput { .. } | SolidError::PortInvariant { .. } => 1007.0,
         SolidError::Upstream { code, .. } => f64::from(*code),
         _ => -1.0,
     }

crates/difftest/src/units/intersect_surface_intersector_p2.rs

@@ -328,7 +328,7 @@ impl From<HarnessError> for Fail {
 /// cannot return.
 fn status(e: &SolidError) -> f64 {
     match e {
-        SolidError::InvalidInput { .. } => 1007.0,
+        SolidError::InvalidInput { .. } | SolidError::PortInvariant { .. } => 1007.0,
         SolidError::Upstream { code, .. } => f64::from(*code),
         _ => -1.0,
     }

crates/difftest/src/units/intersect_surface_intersector_p3.rs

@@ -295,7 +295,7 @@ impl From<HarnessError> for Fail {
 /// cannot return.
 fn status(e: &SolidError) -> f64 {
     match e {
-        SolidError::InvalidInput { .. } => 1007.0,
+        SolidError::InvalidInput { .. } | SolidError::PortInvariant { .. } => 1007.0,
         SolidError::Upstream { code, .. } => f64::from(*code),
         _ => -1.0,
     }

crates/difftest/src/units/intersect_surface_intersector_p4.rs

@@ -290,7 +290,7 @@ impl From<HarnessError> for Fail {
 /// cannot return.
 fn status(e: &SolidError) -> f64 {
     match e {
-        SolidError::InvalidInput { .. } => 1007.0,
+        SolidError::InvalidInput { .. } | SolidError::PortInvariant { .. } => 1007.0,
         SolidError::Upstream { code, .. } => f64::from(*code),
         _ => -1.0,
     }

crates/difftest/src/units/intersect_surface_intersector_p5.rs

@@ -233,7 +233,7 @@ fn cpp(i: &Inputs) -> Result<Output, HarnessError> {
 /// cannot return.
 fn status(e: &SolidError) -> f64 {
     match e {
-        SolidError::InvalidInput { .. } => 1007.0,
+        SolidError::InvalidInput { .. } | SolidError::PortInvariant { .. } => 1007.0,
         SolidError::Upstream { code, .. } => f64::from(*code),
         _ => -1.0,
     }

crates/difftest/src/units/intersect_surface_silhouette.rs

@@ -346,7 +346,7 @@ fn rust_curve(d: &CurveData) -> Result<BSplineCurve, HarnessError> {
 /// cannot return.
 fn status(e: &SolidError) -> f64 {
     match e {
-        SolidError::InvalidInput { .. } => 1007.0,
+        SolidError::InvalidInput { .. } | SolidError::PortInvariant { .. } => 1007.0,
         SolidError::Upstream { code, .. } => f64::from(*code),
         _ => -1.0,
     }

crates/difftest/src/units/intersect_surface_tracer.rs

@@ -512,7 +512,7 @@ impl<'s> SurfaceTrace<'s> for SectionTracer<'s> {
 /// cannot return.
 fn status(e: &SolidError) -> f64 {
     match e {
-        SolidError::InvalidInput { .. } => 1007.0,
+        SolidError::InvalidInput { .. } | SolidError::PortInvariant { .. } => 1007.0,
         SolidError::Upstream { code, .. } => f64::from(*code),
         _ => -1.0,
     }

crates/difftest/src/units/intersect_topology_solver_p1.rs

@@ -749,7 +749,7 @@ impl TopologyObjects<Obj> for Scene {
 /// cannot return.
 fn status(e: &SolidError) -> f64 {
     match e {
-        SolidError::InvalidInput { .. } => 1007.0,
+        SolidError::InvalidInput { .. } | SolidError::PortInvariant { .. } => 1007.0,
         SolidError::Upstream { code, .. } => f64::from(*code),
         _ => -1.0,
     }

crates/difftest/src/units/intersect_topology_solver_p2.rs

@@ -651,7 +651,7 @@ fn static_rust(case: &Case) -> Result<Output, HarnessError> {
                 return Ok(deferred);
             }
             let status = match e {
-                SolidError::InvalidInput { .. } => 1007.0,
+                SolidError::InvalidInput { .. } | SolidError::PortInvariant { .. } => 1007.0,
                 SolidError::Upstream { code, .. } => f64::from(code),
                 _ => return Err(HarnessError::new(e.to_string())),
             };

crates/difftest/src/units/mass_integrator.rs

@@ -49,7 +49,7 @@ fn output(v: Vec<f64>) -> Output {
 }
 fn status(e: &SolidError) -> f64 {
     match e {
-        SolidError::InvalidInput { .. } => 1007.0,
+        SolidError::InvalidInput { .. } | SolidError::PortInvariant { .. } => 1007.0,
         SolidError::Upstream { code, .. } => f64::from(*code),
         _ => 1001.0,
     }

crates/difftest/src/units/nlib_crv_adv_p1.rs

@@ -433,7 +433,7 @@ fn status(e: &SolidError) -> f64 {
         {
             1000.0
         }
-        SolidError::InvalidInput { reason, .. } if *reason == BARE_FLAG_REASON => 1000.0,
+        SolidError::InvalidInput { reason, .. } | SolidError::PortInvariant { reason, .. } if *reason == BARE_FLAG_REASON => 1000.0,
         _ => -1.0,
     }
 }

crates/difftest/src/units/nlib_crv_adv_p2.rs

@@ -566,7 +566,7 @@ fn status(e: &SolidError) -> f64 {
         {
             1000.0
         }
-        SolidError::InvalidInput { reason, .. } if *reason == BARE_FLAG_REASON => 1000.0,
+        SolidError::InvalidInput { reason, .. } | SolidError::PortInvariant { reason, .. } if *reason == BARE_FLAG_REASON => 1000.0,
         _ => -1.0,
     }
 }

crates/difftest/src/units/nlib_crv_approx.rs

@@ -337,7 +337,7 @@ fn status(e: &SolidError) -> f64 {
         SolidError::NotConverged { operation, .. } if operation.starts_with("nurbs::bezier") => {
             1000.0
         }
-        SolidError::InvalidInput { reason, .. } if *reason == BARE_FLAG_REASON => 1000.0,
+        SolidError::InvalidInput { reason, .. } | SolidError::PortInvariant { reason, .. } if *reason == BARE_FLAG_REASON => 1000.0,
         _ => -1.0,
     }
 }

crates/difftest/src/units/nlib_crv_offset.rs

@@ -213,7 +213,7 @@ fn status(e: &SolidError) -> f64 {
         SolidError::NotConverged { operation, .. } if operation.starts_with("nurbs::bezier") => {
             1000.0
         }
-        SolidError::InvalidInput { reason, .. } if *reason == BARE_FLAG_REASON => 1000.0,
+        SolidError::InvalidInput { reason, .. } | SolidError::PortInvariant { reason, .. } if *reason == BARE_FLAG_REASON => 1000.0,
         _ => -1.0,
     }
 }

crates/difftest/src/units/nlib_srf_adv_p1.rs

@@ -428,7 +428,7 @@ fn status<T>(r: &SolidResult<T>) -> f64 {
     match r {
         Ok(_) => 0.0,
         Err(SolidError::Nlib { code, .. }) => f64::from(code.code()),
-        Err(SolidError::InvalidInput { reason, .. }) if *reason == BARE_FLAG_REASON => BARE_FLAG,
+        Err(SolidError::InvalidInput { reason, .. } | SolidError::PortInvariant { reason, .. }) if *reason == BARE_FLAG_REASON => BARE_FLAG,
         Err(SolidError::NotConverged { operation, .. })
             if operation.ends_with("srf_adv::p2::extend_by_dist_at_depth") =>
         {

crates/difftest/src/units/nlib_srf_adv_p4.rs

@@ -462,7 +462,7 @@ fn status<T>(r: &SolidResult<T>) -> f64 {
     match r {
         Ok(_) => 0.0,
         Err(SolidError::Nlib { code, .. }) => f64::from(code.code()),
-        Err(SolidError::InvalidInput { reason, .. }) if *reason == BARE_FLAG_REASON => 1000.0,
+        Err(SolidError::InvalidInput { reason, .. } | SolidError::PortInvariant { reason, .. }) if *reason == BARE_FLAG_REASON => 1000.0,
         Err(_) => -1.0,
     }
 }

crates/difftest/src/units/nurbs_b_spline_curve_n_lib.rs

@@ -726,7 +726,7 @@ fn dump_state(o: &mut Vec<f64>, c: &BSplineCurve) {
 /// The `SmStatus` of a Rust error; `-1` for one upstream cannot return.
 fn status(e: &SolidError) -> f64 {
     match e {
-        SolidError::InvalidInput { .. } => 1007.0,
+        SolidError::InvalidInput { .. } | SolidError::PortInvariant { .. } => 1007.0,
         SolidError::Upstream { code, .. } => f64::from(*code),
         _ => -1.0,
     }

crates/difftest/src/units/nurbs_b_spline_curve_p1.rs

@@ -706,7 +706,7 @@ fn dump_state(o: &mut Vec<f64>, c: &BSplineCurve) {
 /// The `SmStatus` of a Rust error; `-1` for one upstream cannot return.
 fn status(e: &SolidError) -> f64 {
     match e {
-        SolidError::InvalidInput { .. } => 1007.0,
+        SolidError::InvalidInput { .. } | SolidError::PortInvariant { .. } => 1007.0,
         SolidError::Upstream { code, .. } => f64::from(*code),
         _ => -1.0,
     }

crates/difftest/src/units/nurbs_b_spline_curve_p2.rs

@@ -731,7 +731,7 @@ fn dump_state(o: &mut Vec<f64>, c: &BSplineCurve) {
 /// The `SmStatus` of a Rust error; `-1` for one upstream cannot return.
 fn status(e: &SolidError) -> f64 {
     match e {
-        SolidError::InvalidInput { .. } => 1007.0,
+        SolidError::InvalidInput { .. } | SolidError::PortInvariant { .. } => 1007.0,
         SolidError::Upstream { code, .. } => f64::from(*code),
         _ => -1.0,
     }

crates/difftest/src/units/nurbs_b_spline_curve_p3.rs

@@ -510,7 +510,7 @@ fn dump_state(o: &mut Vec<f64>, c: &BSplineCurve) {
 /// The `SmStatus` of a Rust error; `-1` for one upstream cannot return.
 fn status(e: &SolidError) -> f64 {
     match e {
-        SolidError::InvalidInput { .. } => 1007.0,
+        SolidError::InvalidInput { .. } | SolidError::PortInvariant { .. } => 1007.0,
         SolidError::Upstream { code, .. } => f64::from(*code),
         _ => -1.0,
     }

crates/difftest/src/units/nurbs_b_spline_surface_n_lib_p1.rs

@@ -840,7 +840,7 @@ fn dump_curve(o: &mut Vec<f64>, c: &BSplineCurve) {
 /// The `SmStatus` of a Rust error; `-1` for one upstream cannot return.
 fn status(e: &SolidError) -> f64 {
     match e {
-        SolidError::InvalidInput { .. } => 1007.0,
+        SolidError::InvalidInput { .. } | SolidError::PortInvariant { .. } => 1007.0,
         SolidError::Upstream { code, .. } => f64::from(*code),
         _ => -1.0,
     }

crates/difftest/src/units/nurbs_b_spline_surface_n_lib_p2.rs

@@ -680,7 +680,7 @@ fn dump_state(o: &mut Vec<f64>, s: &BSplineSurface) {
 /// The `SmStatus` of a Rust error; `-1` for one upstream cannot return.
 fn status(e: &SolidError) -> f64 {
     match e {
-        SolidError::InvalidInput { .. } => 1007.0,
+        SolidError::InvalidInput { .. } | SolidError::PortInvariant { .. } => 1007.0,
         SolidError::Upstream { code, .. } => f64::from(*code),
         _ => -1.0,
     }