fix(pact_matching): Fix 3 failing pact_verifier tests under V2 engine

- process_array: use !matchers.cascaded so cascaded MinType rules
  degrade to type-check only (fixes verifying_a_pact_with_min_type_matcher_and_child_arrays)
- Add execute_match_values for match:values action — type-check only,
  allowing extra keys (fixes verify_pact_with_match_values_matcher)
- execute_match: push VALUE(STRING) not ERROR so body type error
  message survives through the error template (fixes verify_multiple_pacts pact-one)
- setup_header_plan: add else error branch to per-header if node so
  missing headers produce HeaderMismatch not silence (fixes pact-two)
- header_mismatches: remove stale BodyMismatch block; fix body/header
  ordering in into_mismatches
- Update header_tests and walk_tree_tests to reflect correct new behavior

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: rholshausen

rust/pact_matching/src/engine/bodies/json.rs

@@ -129,7 +129,7 @@ impl JsonPlanBuilder {
         path.last_field().unwrap_or_default(),
         matchers.generate_description(true))));
       root_node.add(build_matching_rule_node(&ExecutionPlanNode::value_node(json.clone()),
-        &ExecutionPlanNode::resolve_current_value(path), &matchers, true,
+        &ExecutionPlanNode::resolve_current_value(path), &matchers, !matchers.cascaded,
         context.config.show_types_in_errors));
 
       if let Some(template) = items.first() {

rust/pact_matching/src/engine/interpreter.rs

@@ -269,6 +269,8 @@ impl ExecutionPlanInterpreter {
       self.execute_match_each_key(value_resolver, node, &action_path)
     } else if action == "match:each-value" {
       self.execute_match_each_value(value_resolver, node, &action_path)
+    } else if action == "match:values" {
+      self.execute_match_values(value_resolver, node, &action_path)
     } else if action.starts_with("match:") {
       match action.strip_prefix("match:") {
         None => {
@@ -931,7 +933,7 @@ impl ExecutionPlanInterpreter {
                   children[2] = else_node.clone();
                   ExecutionPlanNode {
                     node_type: node.node_type.clone(),
-                    result: else_node.result.clone(),
+                    result: else_node.result.clone().map(|r| r.truthy()),
                     children
                   }
                 }
@@ -1331,10 +1333,13 @@ impl ExecutionPlanInterpreter {
               }
               Err(err) => {
                 if let Some(error_node) = optional.first() {
-                  self.push_result(Some(NodeResult::ERROR(err.to_string())));
+                  self.push_result(Some(NodeResult::VALUE(NodeValue::STRING(err.to_string()))));
                   match self.walk_tree(action_path.as_slice(), error_node, value_resolver) {
                     Ok(error_node) => {
-                      let message = error_node.value().unwrap_or_default().as_string().unwrap_or_default();
+                      let message = match error_node.value().unwrap_or_default() {
+                        NodeResult::ERROR(e) => e,
+                        other => other.as_string().unwrap_or_default()
+                      };
                       Err(ExecutionPlanNode {
                         node_type: node.node_type.clone(),
                         result: Some(NodeResult::ERROR(message)),
@@ -1375,6 +1380,37 @@ impl ExecutionPlanInterpreter {
     }
   }
 
+  fn execute_match_values(
+    &mut self,
+    value_resolver: &dyn ValueResolver,
+    node: &ExecutionPlanNode,
+    action_path: &Vec<String>
+  ) -> ExecutionPlanNode {
+    match self.validate_args(4, 0, node, "match:values", value_resolver, action_path) {
+      Ok((args, _)) => {
+        let expected = args[0].value().unwrap_or_default().as_value();
+        let actual = args[1].value().unwrap_or_default().as_value();
+        let ok = match (&expected, &actual) {
+          (Some(NodeValue::JSON(Value::Object(_))), Some(NodeValue::JSON(Value::Object(_)))) => true,
+          (Some(NodeValue::JSON(Value::Array(_))), Some(NodeValue::JSON(Value::Array(_)))) => true,
+          (Some(NodeValue::MMAP(_)), Some(NodeValue::MMAP(_))) => true,
+          (Some(NodeValue::NULL), _) | (_, Some(NodeValue::NULL)) => true,
+          _ => false
+        };
+        ExecutionPlanNode {
+          node_type: node.node_type.clone(),
+          result: Some(if ok {
+            NodeResult::VALUE(NodeValue::BOOL(true))
+          } else {
+            NodeResult::ERROR(format!("Expected type {:?} but was {:?}", expected, actual))
+          }),
+          children: args
+        }
+      }
+      Err(err) => node.clone_with_result(NodeResult::ERROR(err.to_string()))
+    }
+  }
+
   fn execute_match_each_key(
     &mut self,
     value_resolver: &dyn ValueResolver,

rust/pact_matching/src/engine/mod.rs

@@ -1478,12 +1478,12 @@ impl Into<Vec<Mismatch>> for ExecutionPlan {
       if let Some(mismatch) = status_mismatch(&response) {
         result.push(mismatch);
       }
+      let body = body_mismatches(&response);
+      result.extend(body.mismatches());
       let headers = header_mismatches(&response);
       for mismatches in headers.values() {
         result.extend(mismatches.clone());
       }
-      let body = body_mismatches(&response);
-      result.extend(body.mismatches());
     }
 
     if let Some(message) = self.fetch_node(&[":message"]) {
@@ -1580,7 +1580,7 @@ pub(crate) fn query_mismatches(plan: &ExecutionPlanNode) -> HashMap<String, Vec<
 
 pub(crate) fn header_mismatches(plan: &ExecutionPlanNode) -> HashMap<String, Vec<Mismatch>> {
   let headers_node = plan.fetch_child_node(&[":headers"]).unwrap_or_default();
-  let mut headers = headers_node.children.iter()
+  let headers = headers_node.children.iter()
     .fold(hashmap! {}, |mut acc, child| {
       if let PlanNodeType::CONTAINER(label) = &child.node_type {
         let mismatches = child.errors().iter().map(|err| HeaderMismatch {
@@ -1605,18 +1605,6 @@ pub(crate) fn header_mismatches(plan: &ExecutionPlanNode) -> HashMap<String, Vec
       };
       acc
     });
-  let errors = headers_node.child_errors(Terminator::CONTAINERS);
-  if !errors.is_empty() {
-    let mismatches = errors.iter()
-      .map(|err| BodyMismatch {
-        path: "".to_string(),
-        expected: None,
-        actual: None,
-        mismatch: err.clone(),
-      })
-      .collect_vec();
-    headers.insert("".to_string(), mismatches);
-  }
   headers
 }
 
@@ -2017,6 +2005,13 @@ fn setup_header_plan<T: HttpPart>(
           presence_check.add(item_check);
         }
 
+        presence_check.add(
+          ExecutionPlanNode::action("error")
+            .add(ExecutionPlanNode::value_node(
+              format!("Expected header '{}' but was missing", key)
+            ))
+        );
+
         item_node.add(presence_check);
         plan_node.add(item_node);
       }