[BUG] Manifest-initial-offset was not set under gc conditions. (#4903)

## Description of changes

I noticed this is still not being set right.  Add a unit test and update
the prop tests to be more thorough.

## Test plan

- [X] Tests pass locally with `pytest` for python, `yarn test` for js,
`cargo test` for rust

## Documentation Changes

N/A

Author: rescrv

rust/wal3/src/manifest.rs

@@ -811,6 +811,12 @@ impl Manifest {
     /// Apply the destructive operation specified by the Garbage struct.
     #[allow(clippy::result_large_err)]
     pub fn apply_garbage(&self, mut garbage: Garbage) -> Result<Self, Error> {
+        if garbage.fragments_to_drop_start > garbage.fragments_to_drop_limit {
+            return Err(Error::GarbageCollection(format!(
+                "Garbage has start > limit: {:?} > {:?}",
+                garbage.fragments_to_drop_start, garbage.fragments_to_drop_limit
+            )));
+        }
         let mut new = self.clone();
         for to_drop in garbage.snapshots_to_drop.iter() {
             if let Some(index) = new.snapshots.iter().position(|s| s == to_drop) {
@@ -834,8 +840,12 @@ impl Manifest {
         }
         new.collected += garbage.setsum_to_discard;
         new.initial_offset = Some(garbage.first_to_keep);
-        if garbage.fragments_to_drop_start < garbage.fragments_to_drop_limit {
+        if garbage.fragments_to_drop_start != FragmentSeqNo(0)
+            || garbage.fragments_to_drop_start < garbage.fragments_to_drop_limit
+        {
             new.initial_seq_no = Some(garbage.fragments_to_drop_limit);
+        } else {
+            new.initial_seq_no = Some(FragmentSeqNo(1));
         }
         new.scrub()?;
         Ok(new)
@@ -1483,4 +1493,91 @@ mod tests {
             LogPosition::from_offset(500)
         );
     }
+
+    #[test]
+    fn apply_garbage_equal_nonzero_fragment_seq_nos() {
+        let manifest = Manifest {
+            writer: "test_writer".to_string(),
+            setsum: Setsum::default(),
+            collected: Setsum::default(),
+            acc_bytes: 0,
+            snapshots: vec![],
+            fragments: vec![],
+            initial_offset: None,
+            initial_seq_no: None,
+        };
+
+        let garbage = Garbage {
+            snapshots_to_drop: vec![],
+            snapshots_to_make: vec![],
+            fragments_to_drop_start: FragmentSeqNo(5),
+            fragments_to_drop_limit: FragmentSeqNo(5),
+            setsum_to_discard: Setsum::default(),
+            first_to_keep: LogPosition::from_offset(100),
+            snapshot_for_root: None,
+        };
+
+        let result = manifest.apply_garbage(garbage).unwrap();
+
+        // When fragments_to_drop_start == fragments_to_drop_limit and both are non-zero,
+        // initial_seq_no should be set to the limit value
+        assert_eq!(result.initial_seq_no, Some(FragmentSeqNo(5)));
+        assert_eq!(result.initial_offset, Some(LogPosition::from_offset(100)));
+    }
+
+    #[test]
+    fn apply_garbage_validates_fragment_drop_range() {
+        use crate::gc::Garbage;
+
+        let manifest = Manifest::new_empty("test");
+
+        // Test case: fragments_to_drop_start > fragments_to_drop_limit should fail
+        let invalid_garbage = Garbage {
+            snapshots_to_drop: vec![],
+            snapshots_to_make: vec![],
+            snapshot_for_root: None,
+            fragments_to_drop_start: FragmentSeqNo(10),
+            fragments_to_drop_limit: FragmentSeqNo(5),
+            setsum_to_discard: Setsum::default(),
+            first_to_keep: LogPosition::from_offset(1),
+        };
+
+        let result = manifest.apply_garbage(invalid_garbage);
+        assert!(result.is_err());
+
+        if let Err(crate::Error::GarbageCollection(msg)) = result {
+            assert!(msg.contains("Garbage has start > limit"));
+            assert!(msg.contains("FragmentSeqNo(10) > FragmentSeqNo(5)"));
+        } else {
+            panic!("Expected GarbageCollection error, got {:?}", result);
+        }
+
+        // Test case: fragments_to_drop_start == fragments_to_drop_limit should succeed
+        let valid_garbage_equal = Garbage {
+            snapshots_to_drop: vec![],
+            snapshots_to_make: vec![],
+            snapshot_for_root: None,
+            fragments_to_drop_start: FragmentSeqNo(5),
+            fragments_to_drop_limit: FragmentSeqNo(5),
+            setsum_to_discard: Setsum::default(),
+            first_to_keep: LogPosition::from_offset(1),
+        };
+
+        let result = manifest.apply_garbage(valid_garbage_equal);
+        assert!(result.is_ok());
+
+        // Test case: fragments_to_drop_start < fragments_to_drop_limit should succeed
+        let valid_garbage_less = Garbage {
+            snapshots_to_drop: vec![],
+            snapshots_to_make: vec![],
+            snapshot_for_root: None,
+            fragments_to_drop_start: FragmentSeqNo(1),
+            fragments_to_drop_limit: FragmentSeqNo(5),
+            setsum_to_discard: Setsum::default(),
+            first_to_keep: LogPosition::from_offset(1),
+        };
+
+        let result = manifest.apply_garbage(valid_garbage_less);
+        assert!(result.is_ok());
+    }
 }

rust/wal3/tests/test_k8s_integration_0_properties.rs

@@ -188,6 +188,7 @@ proptest::proptest! {
             snapshots: snapshots.clone(),
         };
         eprintln!("[{:?}, {:?})", start, limit);
+        let mut last_initial_seq_no = FragmentSeqNo(0);
         for offset in start.offset()..limit.offset() {
             let position = LogPosition::from_offset(offset);
             eprintln!("position = {position:?}");
@@ -203,6 +204,11 @@ proptest::proptest! {
             assert_eq!(manifest.setsum, new_manifest.setsum, "manifest.setsum mismatch");
             assert_eq!(manifest.collected + dropped, new_manifest.collected, "manifest.collected mismatch");
             assert!(new_manifest.scrub().is_ok(), "scrub error");
+            assert!(new_manifest.initial_seq_no.is_some() || new_manifest.initial_offset.is_none());
+            if new_manifest.initial_seq_no.is_some() {
+                assert!(new_manifest.initial_seq_no.unwrap() >= last_initial_seq_no);
+                last_initial_seq_no = new_manifest.initial_seq_no.unwrap();
+            }
         }
     }
 }