Integrate release recovery, semantic review, coverage and Windows packaging

crates/oa-core/tests/r3_semantic.rs

@@ -642,6 +642,11 @@ fn atomic_annotation_full_path_updates_only_selected_row() {
     let rows = values_mut(&mut q, b.message);
     assert_eq!(rows.len(), 2);
     assert!(rows.contains(&retained));
+    assert_eq!(AnnotationKey::from(&rows[0]), b.first);
+    assert_eq!(
+        rows[1], retained,
+        "Unselected rows retain their authored position"
+    );
     assert!(
         rows.iter()
             .any(|v| AnnotationKey::from(v) == b.first && v.expression == "new first")
@@ -651,6 +656,73 @@ fn atomic_annotation_full_path_updates_only_selected_row() {
             .any(|v| AnnotationKey::from(v) == b.second && v.expression == retained.expression)
     );
 }
+
+#[test]
+fn keeping_keyed_rows_with_an_unrelated_header_candidate_preserves_exact_authored_order() {
+    for binding in [false, true] {
+        for reverse in [false, true] {
+            let mut p = Project::empty();
+            let (oa, sa, selector, references) = if binding {
+                let a = scenario_use(&mut p, Layer::Oa, "oa");
+                let b = scenario_use(&mut p, Layer::Sa, "sa");
+                (
+                    a.use_id,
+                    b.use_id,
+                    FacetSelector::Binding(KeyPair {
+                        oa: Some(a.referenced),
+                        sa: Some(b.referenced),
+                    }),
+                    BTreeMap::from([(a.referenced, b.referenced)]),
+                )
+            } else {
+                let a = payload(&mut p, Layer::Oa, "oa");
+                let b = payload(&mut p, Layer::Sa, "sa");
+                let mut references: BTreeMap<_, _> = a
+                    .first
+                    .path
+                    .iter()
+                    .copied()
+                    .zip(b.first.path.iter().copied())
+                    .collect();
+                references.insert(a.leaf, b.leaf);
+                (
+                    a.message,
+                    b.message,
+                    FacetSelector::Annotation(KeyPair {
+                        oa: Some(a.first),
+                        sa: Some(b.first),
+                    }),
+                    references,
+                )
+            };
+            trace(&mut p, oa, sa);
+            let (source, target) = if reverse { (sa, oa) } else { (oa, sa) };
+            let mut candidate = p.elements[&target].clone();
+            candidate.description = "Review the header while retaining authored rows".into();
+            let mut review = request(
+                source,
+                target,
+                vec![
+                    (selector, SemanticDecision::KeepTarget),
+                    (
+                        FacetSelector::Header(HeaderFacet::Description),
+                        SemanticDecision::Candidate,
+                    ),
+                ],
+            );
+            if reverse {
+                review.transition.direction = TransitionDirection::SaToOa;
+            }
+            review.references = references;
+            review
+                .candidates
+                .push(SemanticRecord::Element(candidate.clone()));
+            let accepted = applied(&p, review);
+            assert_eq!(accepted.elements[&target], candidate);
+            assert_eq!(accepted.elements[&source], p.elements[&source]);
+        }
+    }
+}
 #[test]
 fn atomic_binding_updates_local_and_rejects_pair_collision_and_remapping_without_reset() {
     let mut p = Project::empty();
@@ -671,6 +743,8 @@ fn atomic_binding_updates_local_and_rejects_pair_collision_and_remapping_without
     r.references = BTreeMap::from([(a.referenced, b.referenced), (a.alternate, b.alternate)]);
     let mut q = applied(&p, r.clone());
     assert!(bindings_mut(&mut q, b.use_id).contains(&retained));
+    assert_eq!(bindings_mut(&mut q, b.use_id)[0].referenced, b.referenced);
+    assert_eq!(bindings_mut(&mut q, b.use_id)[1], retained);
     assert!(
         bindings_mut(&mut q, b.use_id)
             .iter()