UndoManager: element removed from the array after a sequence of mixed changes/undos/redos

[obeah]

Hi,

New sequence that produces incorrect result from time to time.
The test is wrapped in the loop that breaks after the problem occurs.

for idx in 0..1000 {
            let d = Doc::new();
            let r = d.get_or_insert_map("r");
            let s1 = r.insert(&mut d.transact_mut(), "s1", MapPrelim::<i32>::new());
            let b1_arr = s1.insert(&mut d.transact_mut(), "b1", ArrayPrelim::default());

            let b1_el0 = b1_arr.insert(&mut d.transact_mut(), 0, MapPrelim::<i32>::new());
            let b2_arr = b1_el0.insert(&mut d.transact_mut(), "b2", ArrayPrelim::default());
            let b2_arr_nest0 = b2_arr.insert(&mut d.transact_mut(), 0, ArrayPrelim::default());
            b2_arr_nest0.insert(&mut d.transact_mut(), 0, "A1");
            b2_arr_nest0.insert(&mut d.transact_mut(), 1, "A2");
            let b2_arr_nest1 = b2_arr.insert(&mut d.transact_mut(), 1, ArrayPrelim::default());
            b2_arr_nest1.insert(&mut d.transact_mut(), 0, "B1");
            b2_arr_nest1.insert(&mut d.transact_mut(), 1, "B2");
            b1_el0.insert(&mut d.transact_mut(), "f21", false);
            b1_el0.insert(&mut d.transact_mut(), "f22", "C");

            let json_before = r.to_json(&d.transact());

            if idx == 0 {
                println!("Initial: {}", json_before);
            }
            // println!("Before undo manager: {}", r.to_json(&d.transact()));

            let mut mgr = UndoManager::with_options(&d, &r, Options::default());
            //
            let mut txn = d.transact_mut();
            b2_arr_nest1.remove(&mut txn, 0);
            b2_arr_nest1.insert(&mut txn, 0, "R1");

            drop(txn);
            mgr.reset();
            // println!("After txn 1: {}", r.to_json(&d.transact()));

            mgr.undo().unwrap();
            // println!("After undo 1: {}", r.to_json(&d.transact()));

            mgr.redo().unwrap();
            // println!("After redo 1: {}", r.to_json(&d.transact()));

            let mut txn = d.transact_mut();

            let b1_el0_new = b1_arr.insert(&mut txn, 0, MapPrelim::<i32>::new());
            let b2_arr = b1_el0_new.insert(&mut txn, "b2", ArrayPrelim::default());
            let b2_arr_nest0 = b2_arr.insert(&mut txn, 0, ArrayPrelim::default());
            b2_arr_nest0.insert(&mut txn, 0, "A1");
            b2_arr_nest0.insert(&mut txn, 1, "A2");
            let b2_arr_nest1 = b2_arr.insert(&mut txn, 1, ArrayPrelim::default());
            b2_arr_nest1.insert(&mut txn, 0, "R1");
            b2_arr_nest1.insert(&mut txn, 1, "B2");
            b1_el0_new.insert(&mut txn, "f21", false);
            b1_el0_new.insert(&mut txn, "f22", "R2");

            b1_el0.remove(&mut txn, "b2");
            b1_el0.remove(&mut txn, "f21");
            b1_el0.insert(&mut txn, "f22", "R3");

            drop(txn);
            mgr.reset();
            // println!("After txn 2: {}", r.to_json(&d.transact()));
            //
            // println!("Before undo sequence: {}", r.to_json(&d.transact()));
            mgr.undo().unwrap();
            // println!("After undo 1: {}", r.to_json(&d.transact()));
            mgr.undo().unwrap();
            let json_after = r.to_json(&d.transact());
            if json_before != json_after {
                println!("Iteration {}, final json with error: {}", idx, json_after);
                break;
            }
        }

Output (B2 is lost):

Initial: {s1: {b1: [{b2: [[A1, A2], [B1, B2]], f22: C, f21: false}]}}
Iteration 33, final json with error: {s1: {b1: [{f21: false, f22: C, b2: [[A1, A2], [B1]]}]}}