perf: improve text checkout scalability

crates/fuzz/src/crdt_fuzzer.rs

@@ -731,6 +731,15 @@ pub fn test_multi_sites_with_gc(
                 let (a, b) = array_mut_ref!(&mut this.actors, [i, j]);
                 let a_doc = &mut a.loro;
                 let b_doc = &mut b.loro;
+                let a_shallow = a_doc.is_shallow();
+                let b_shallow = b_doc.is_shallow();
+                // Shallow docs cannot export ops before the shallow root, so
+                // they cannot sync complete history to empty peers. This mirrors
+                // the non-GC `check_equal` guard.
+                if a_shallow || b_shallow {
+                    continue;
+                }
+
                 info_span!("Attach", peer = i).in_scope(|| {
                     a_doc.attach();
                 });

crates/fuzz/src/one_doc_fuzzer.rs

@@ -551,7 +551,11 @@ impl OneDocFuzzer {
                                         peer: before.0,
                                         counter: before.1,
                                     };
-                                    tree.mov_before(target, before).unwrap();
+                                    if let Err(LoroError::TreeError(e)) =
+                                        tree.mov_before(target, before)
+                                    {
+                                        tracing::warn!("move error {}", e);
+                                    }
                                 }
                                 crate::container::TreeActionInner::MoveAfter { target, after } => {
                                     let target = TreeID {
@@ -562,7 +566,11 @@ impl OneDocFuzzer {
                                         peer: after.0,
                                         counter: after.1,
                                     };
-                                    tree.mov_after(target, after).unwrap();
+                                    if let Err(LoroError::TreeError(e)) =
+                                        tree.mov_after(target, after)
+                                    {
+                                        tracing::warn!("move error {}", e);
+                                    }
                                 }
                                 crate::container::TreeActionInner::Meta { meta: (k, v) } => {
                                     let meta = tree.get_meta(target).unwrap();

crates/fuzz/tests/test.rs

@@ -172,6 +172,163 @@ fn all_fuzz_state_only_before_shallow_root() {
     )
 }
 
+#[test]
+fn all_fuzz_state_only_roundtrip_after_diff_apply_text_update() {
+    test_multi_sites(
+        5,
+        vec![FuzzTarget::All],
+        &mut [
+            Handle {
+                site: 196,
+                target: 0,
+                container: 151,
+                action: Generic(GenericAction {
+                    value: Container(List),
+                    bool: true,
+                    key: 1835887981,
+                    pos: 15359179523395251565,
+                    length: 6845301837235606980,
+                    prop: 4959913191460359423,
+                }),
+            },
+            SyncAll,
+            SyncAll,
+            SetCommitOptions {
+                site: 255,
+                origin: 255,
+                msg: 93,
+            },
+            Handle {
+                site: 0,
+                target: 0,
+                container: 0,
+                action: Generic(GenericAction {
+                    value: Container(Unknown(255)),
+                    bool: true,
+                    key: 4294967295,
+                    pos: 3225938275189391359,
+                    length: 7885078839350357357,
+                    prop: 3617008642897571181,
+                }),
+            },
+            DiffApply { from: 125, to: 178 },
+            SetCommitOptions {
+                site: 242,
+                origin: 242,
+                msg: 242,
+            },
+            DiffApply { from: 255, to: 255 },
+            SetCommitOptions {
+                site: 109,
+                origin: 109,
+                msg: 109,
+            },
+            SyncAll,
+            ForkAt {
+                site: 109,
+                to: 1835887981,
+            },
+            SyncAll,
+            SyncAll,
+            SyncAll,
+            SyncAll,
+            SyncAll,
+            SyncAll,
+            SyncAll,
+            SyncAll,
+            Sync { from: 91, to: 91 },
+            Sync { from: 91, to: 91 },
+            SyncAll,
+            StateOnlyRoundTrip { site: 213 },
+            SyncAll,
+            StateOnlyRoundTrip { site: 255 },
+        ],
+    )
+}
+
+#[test]
+fn all_fuzz_one_doc_ignores_cyclic_move_before_error() {
+    test_multi_sites_on_one_doc(
+        5,
+        &mut [
+            Handle {
+                site: 11,
+                target: 148,
+                container: 148,
+                action: Generic(GenericAction {
+                    value: I32(0),
+                    bool: false,
+                    key: 65296,
+                    pos: 18446744073709551600,
+                    length: 18446744073709551615,
+                    prop: 11240984665823117311,
+                }),
+            },
+            Query {
+                site: 125,
+                target: 125,
+                query_type: 119,
+            },
+            Handle {
+                site: 0,
+                target: 125,
+                container: 125,
+                action: Generic(GenericAction {
+                    value: I32(2105376125),
+                    bool: true,
+                    key: 2105376125,
+                    pos: 9042521604759584125,
+                    length: 9042521604759584125,
+                    prop: 9042521604759584125,
+                }),
+            },
+            ForkAt {
+                site: 125,
+                to: 2105376125,
+            },
+            Query {
+                site: 155,
+                target: 155,
+                query_type: 155,
+            },
+            SyncAll,
+            SyncAll,
+            SyncAll,
+            SyncAll,
+            SyncAll,
+            SyncAll,
+            SyncAll,
+            Handle {
+                site: 3,
+                target: 136,
+                container: 107,
+                action: Generic(GenericAction {
+                    value: I32(1802075016),
+                    bool: true,
+                    key: 1802201963,
+                    pos: 7740429931049413483,
+                    length: 285424485,
+                    prop: 29704420010754048,
+                }),
+            },
+            SyncAll,
+            Handle {
+                site: 3,
+                target: 136,
+                container: 107,
+                action: Generic(GenericAction {
+                    value: I32(1802070920),
+                    bool: true,
+                    key: 1929407339,
+                    pos: 3026537059180544374,
+                    length: 232891317779694337,
+                    prop: 3124043742624574344,
+                }),
+            },
+        ],
+    )
+}
+
 #[test]
 fn test_local_events() {
     fuzz_local_events(vec![
@@ -10051,6 +10208,35 @@ fn shallow_arb_test() {
     arbtest::builder().budget_ms(1000).run(|u| prop(u, 5))
 }
 
+#[test]
+fn shallow_import_after_empty_shallow_export_and_text_edit_converges() {
+    test_multi_sites_with_gc(
+        5,
+        vec![FuzzTarget::All],
+        &mut [
+            Commit { site: 54 },
+            ExportShallow { site: 160 },
+            Handle {
+                site: 85,
+                target: 222,
+                container: 228,
+                action: Generic(GenericAction {
+                    value: Container(Map),
+                    bool: false,
+                    key: 441515985,
+                    pos: 11802333225252155855,
+                    length: 9719789893245689708,
+                    prop: 1572726038975133702,
+                }),
+            },
+            ImportShallow {
+                site: 21,
+                from: 240,
+            },
+        ],
+    )
+}
+
 #[test]
 fn shallow_fuzz_snapshot_after_shallow_import_and_diff_apply() {
     test_multi_sites_with_gc(

crates/loro-common/src/lib.rs

@@ -366,6 +366,26 @@ impl ContainerType {
         }
     }
 
+    /// Returns whether importing ops for this container type may need import
+    /// rollback protection during state diff application.
+    ///
+    /// This is used by import preflight: if an imported or newly-unblocked
+    /// pending change touches one of these container types, the oplog enables
+    /// rollback bookkeeping before applying the change to the document state.
+    /// Keep this list aligned with container states whose diff validation or
+    /// application can return an error after the oplog has already advanced.
+    ///
+    /// Container types not listed here may still be complex, but their current
+    /// state-apply path does not report recoverable errors through
+    /// `LoroResult`, so enabling rollback for them would only add import
+    /// overhead.
+    pub fn may_need_state_apply_rollback(&self) -> bool {
+        matches!(
+            self,
+            ContainerType::List | ContainerType::Text | ContainerType::Tree
+        )
+    }
+
     pub fn to_u8(self) -> u8 {
         match self {
             ContainerType::Map => 0,

crates/loro-internal/Cargo.toml

@@ -101,6 +101,10 @@ jsonpath = []
 name = "text_r"
 harness = false
 
+[[bench]]
+name = "text_checkout"
+harness = false
+
 [[bench]]
 name = "list"
 harness = false