perf: speed up B4 local editing ~2.4x and snapshot import ~45% (#1033)

* perf: speed up B4 local editing (~42%) and snapshot import (~45%)

Local text editing (applying the automerge-paper trace): ~112ms -> ~65ms.
- Compile the lock-order debug instrumentation out of release builds; it ran on
  every per-op OpLog+DocState lock acquire/release (~30% of edit time). In
  release `can_lock_in_this_thread` returns false, backed by the now-exact
  cached visible op count.
- Bump `visible_op_count` incrementally for local ops instead of recomputing it
  from the version vectors (which also heap-allocated an im::HashMap iterator)
  on every op.
- Build the position-context error string in `checked_range_end` lazily (no
  per-op alloc) and return entity ranges in a SmallVec (no per-delete Vec alloc).
- Route the per-insert event-index computation through the existing cursor cache
  instead of a fresh `visit_previous_caches` walk every op.

Snapshot import (fast snapshot): B4 ~135us -> ~80us; B4x100 (22MB) ~8.15ms -> ~4.5ms.
- Skip the redundant per-block SSTable checksum on full import; the whole body
  is already covered by the document checksum verified in parse_header_and_body.

Adds crates/examples/examples/b4_bench.rs (phase-timed B4 harness) plus
regression tests for the cached visible op count and the block-checksum skip.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* perf: avoid per-op heap alloc in DocState::is_deleted

`is_deleted` allocated a fresh `visited` Vec on every local op (the #1
allocation source after the earlier fixes: ~260k allocs on the B4 trace).
Parent chains are shallow (depth 1 for a root container), so use inline
SmallVec storage. apply 1x: ~65ms -> ~61ms.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* chore: vendor generic-btree into the workspace

Fork crates.io generic-btree 0.10.7 (which loro-dev maintains) into
crates/generic-btree and redirect all dependents via [patch.crates-io], so the
b-tree can evolve in-tree (e.g. deferred cache propagation). This is a verbatim
vendoring of 0.10.7 (build is transparent: B4 apply unchanged at ~62ms); only
the manifest is trimmed (benches dropped, dev-deps reduced to what the in-src
tests need).

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* perf: fast path for plain-text local edits (B4 apply ~61ms -> ~46ms)

Add a specialized insert/delete path for style-free text on the attached,
non-wasm, unicode-index path (the common Rust text-editing case). When the
richtext has no style anchors, entity_index == event_index == unicode pos, so
the entire read phase -- cursor location, two `visit_previous_caches` coordinate
walks, and the styles lookup -- is unnecessary; `apply_local_op` then locates the
cursor exactly once. The delete path likewise skips the two `index_to_event_index`
walks. Falls back to the general path when styles are present, on wasm, or for
non-unicode position types, so results are unchanged (snapshot bytes identical;
loro, loro-internal lib, and mergeable tests all pass).

Also gate `apply_local_op`'s txn/doc context check (a per-op `Weak::upgrade`) to
debug builds, since the handler always passes its own doc.

Cumulative B4 apply: 112ms -> ~46ms (~2.4x), ~11.5 M op/s.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* fix: keep integrity checks on public APIs (review fixes)

Address two correctness regressions introduced by the B4 perf work:

1. The txn/doc context check in `Transaction::apply_local_op` was gated to
   debug builds. `insert_with_txn`/`delete_with_txn` are public API, so a
   caller can feed one document's transaction to another document's handler;
   in release that silently stamped the target doc's state/oplog with the
   wrong peer+counter instead of returning `UnmatchedContext`. Restore the
   check for all builds using a cheap `Weak`-pointer comparison (no atomic
   upgrade on the hot path; upgrade only to fill in the error on mismatch).

2. `MemKvStore::import_all` (re-exported publicly via loro-crdt) dropped
   per-block checksums for all callers. Split the API: public `import_all`
   (and `SsTable::import_all`) always verifies block checksums; a new
   `import_all_unchecked` opts into the fast path and is used only by Loro's
   snapshot decode (`ChangeStore::import_all`, `KvWrapper::import`), where the
   document-level checksum from `parse_header_and_body` already guarantees
   integrity over the whole body.

Adds regression tests: `cross_doc_txn_is_rejected` and the updated
`sstable_import_block_checksum_only_skipped_when_unchecked`.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* chore: make fuzz sanitizer platform-aware

---------

Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: zxch3n

.changeset/fast-sstable-import.md

@@ -2,4 +2,6 @@
 "loro-crdt": patch
 ---
 
-Improve snapshot import performance by skipping eager SSTable block metadata validation on fast imports while still verifying block checksums.
+Speed up snapshot import. When decoding a Loro snapshot, the redundant per-block SSTable validation (eager block-metadata decode and per-block checksums) is now skipped, because the whole snapshot body is already protected by the document-level checksum verified during decoding. This removes a second hash pass over the data (roughly halving B4 snapshot import time) while preserving integrity guarantees.
+
+This fast path is internal to Loro's snapshot decoding. The public `MemKvStore::import_all` still verifies every block's checksum; a separate `import_all_unchecked` opts into the unchecked path and is only used where an outer checksum already guarantees integrity.

.changeset/faster-local-text-editing.md

@@ -0,0 +1,11 @@
+---
+"loro-crdt": patch
+---
+
+Speed up local text editing (~35% faster on the B4 editing trace). Three hot-path
+changes: the lock-order debug instrumentation is now compiled out of release
+builds (it ran on every per-op lock acquisition); the visible-op count is bumped
+incrementally for local ops instead of recomputing it from the version vectors
+(which also allocated) on every op; and a couple of per-op allocations on the
+text insert/delete path were removed (lazy error-context formatting and inline
+storage for entity ranges).

Cargo.lock

@@ -13,9 +13,15 @@ members = [
     "crates/delta",
     "crates/kv-store",
     "crates/loro-wasm-tools",
+    "crates/generic-btree",
 ]
 resolver = "2"
 
+# Use the in-tree fork of generic-btree (loro-dev maintains it). This redirects
+# every `generic-btree` dependency in the graph to the workspace crate.
+[patch.crates-io]
+generic-btree = { path = "crates/generic-btree" }
+
 [workspace.dependencies]
 enum_dispatch = "0.3.11"
 enum-as-inner = "0.6.0"
@@ -31,4 +37,3 @@ bytes = "1"
 once_cell = "1.18.0"
 xxhash-rust = { version = "0.8.12", features = ["xxh32"] }
 ensure-cov = "0.1.0"
-either = "1.13.0"

Cargo.toml

@@ -0,0 +1,181 @@
+//! B4 (automerge-paper) performance harness.
+//!
+//! Usage:
+//!   cargo run --release -p examples --example b4_bench            # phase report
+//!   cargo run --release -p examples --example b4_bench edit       # tight edit loop (for profiler)
+//!   cargo run --release -p examples --example b4_bench import     # tight import loop (for profiler)
+//!   cargo run --release -p examples --example b4_bench import100  # tight import loop for B4x100
+use std::time::{Duration, Instant};
+
+use bench_utils::{get_automerge_actions, TextAction};
+use dev_utils::{get_mem_usage, ByteSize};
+use loro::{ExportMode, LoroDoc};
+
+fn apply(actions: &[TextAction], n: usize) -> LoroDoc {
+    let doc = LoroDoc::new();
+    let text = doc.get_text("text");
+    for _ in 0..n {
+        for TextAction { del, ins, pos } in actions.iter() {
+            text.delete(*pos, *del).unwrap();
+            text.insert(*pos, ins).unwrap();
+        }
+    }
+    doc.commit();
+    doc
+}
+
+fn median(mut v: Vec<Duration>) -> Duration {
+    v.sort();
+    v[v.len() / 2]
+}
+
+fn time<T>(runs: usize, mut f: impl FnMut() -> T) -> (Duration, T) {
+    let mut last = None;
+    let mut times = Vec::new();
+    for _ in 0..runs {
+        let start = Instant::now();
+        let r = f();
+        times.push(start.elapsed());
+        last = Some(r);
+    }
+    (median(times), last.unwrap())
+}
+
+fn report() {
+    let actions = get_automerge_actions();
+    let total_ops: usize = actions.len();
+    println!("B4 actions: {total_ops} (each = 1 delete + 1 insert)\n");
+
+    // ---- Local editing ----
+    let mem0 = get_mem_usage();
+    let (t_apply, doc) = time(5, || apply(&actions, 1));
+    let mem_after_apply = get_mem_usage() - mem0;
+    println!("== Local editing (one big txn, no subscriber) ==");
+    println!(
+        "  apply 1x:            {:>10.2?}   ({:.2} M op/s, {:.0} ns/op)",
+        t_apply,
+        (2 * total_ops) as f64 / t_apply.as_secs_f64() / 1e6,
+        t_apply.as_nanos() as f64 / (2 * total_ops) as f64
+    );
+    println!("  doc mem after apply: {}", mem_after_apply);
+
+    // ---- Snapshot export ----
+    let (t_export, snapshot) = time(5, || doc.export(ExportMode::Snapshot).unwrap());
+    println!("\n== Snapshot export ==");
+    println!("  export (has cache):  {:>10.2?}", t_export);
+    println!("  snapshot size:       {}", ByteSize(snapshot.len()));
+
+    let (t_export_nc, _) = time(5, || {
+        let d = apply(&actions, 1);
+        d.export(ExportMode::Snapshot).unwrap()
+    });
+    println!("  export(+apply,nocache):{:>8.2?}  (includes a fresh apply)", t_export_nc);
+
+    // ---- Snapshot import ----
+    let mem_before = get_mem_usage();
+    let (t_import, imported) = time(5, || {
+        let d = LoroDoc::new();
+        d.import(&snapshot).unwrap();
+        d
+    });
+    let mem_imported = get_mem_usage() - mem_before;
+    println!("\n== Snapshot import (B4) ==");
+    println!("  import:              {:>10.2?}", t_import);
+    println!("  mem after import:    {}", mem_imported);
+
+    let (t_import_val, _) = time(5, || {
+        let d = LoroDoc::new();
+        d.import(&snapshot).unwrap();
+        let v = d.get_deep_value();
+        std::hint::black_box(v);
+    });
+    println!("  import + toJSON:     {:>10.2?}  (forces full state materialization)", t_import_val);
+    std::hint::black_box(&imported);
+
+    // ---- B4 x100 ----
+    let (t_apply100, doc100) = time(1, || apply(&actions, 100));
+    let snap100 = doc100.export(ExportMode::Snapshot).unwrap();
+    println!("\n== B4 x100 ==");
+    println!("  apply 100x:          {:>10.2?}", t_apply100);
+    println!("  snapshot size:       {}", ByteSize(snap100.len()));
+    let (t_import100, _) = time(5, || {
+        let d = LoroDoc::new();
+        d.import(&snap100).unwrap();
+        d
+    });
+    println!("  import:              {:>10.2?}", t_import100);
+    let (t_import100_val, _) = time(5, || {
+        let d = LoroDoc::new();
+        d.import(&snap100).unwrap();
+        std::hint::black_box(d.get_deep_value());
+    });
+    println!("  import + toJSON:     {:>10.2?}", t_import100_val);
+
+    // ---- updates encode/decode (history path) ----
+    let updates = doc.export(ExportMode::all_updates()).unwrap();
+    println!("\n== Updates (history) ==");
+    println!("  updates size:        {}", ByteSize(updates.len()));
+    let (t_dec_updates, _) = time(5, || {
+        let d = LoroDoc::new();
+        d.import(&updates).unwrap();
+        d
+    });
+    println!("  import updates:      {:>10.2?}", t_dec_updates);
+}
+
+/// Tight loop over `f` for `secs` seconds. Use with an external sampling
+/// profiler, e.g.:
+///   cargo instruments -t time --release -p examples --example b4_bench -- edit 20
+fn loop_for(secs: u64, _label: &str, mut f: impl FnMut()) {
+    let start = Instant::now();
+    let mut iters = 0u64;
+    while start.elapsed() < Duration::from_secs(secs) {
+        f();
+        iters += 1;
+    }
+    eprintln!("ran {iters} iters in {:?}", start.elapsed());
+}
+
+fn main() {
+    let mode = std::env::args().nth(1).unwrap_or_default();
+    let secs: u64 = std::env::args()
+        .nth(2)
+        .and_then(|s| s.parse().ok())
+        .unwrap_or(12);
+    match mode.as_str() {
+        "edit" => {
+            let actions = get_automerge_actions();
+            loop_for(secs, "edit", || {
+                std::hint::black_box(apply(&actions, 1));
+            });
+        }
+        "import" => {
+            let actions = get_automerge_actions();
+            let snapshot = apply(&actions, 1).export(ExportMode::Snapshot).unwrap();
+            loop_for(secs, "import", || {
+                let d = LoroDoc::new();
+                d.import(&snapshot).unwrap();
+                std::hint::black_box(d);
+            });
+        }
+        "import100" => {
+            let actions = get_automerge_actions();
+            let snapshot = apply(&actions, 100).export(ExportMode::Snapshot).unwrap();
+            loop_for(secs, "import100", || {
+                let d = LoroDoc::new();
+                d.import(&snapshot).unwrap();
+                std::hint::black_box(d);
+            });
+        }
+        "import_val" => {
+            let actions = get_automerge_actions();
+            let snapshot = apply(&actions, 1).export(ExportMode::Snapshot).unwrap();
+            loop_for(secs, "import_val", || {
+                let d = LoroDoc::new();
+                d.import(&snapshot).unwrap();
+                std::hint::black_box(d.get_deep_value());
+            });
+        }
+        _ => report(),
+    }
+}

crates/examples/examples/b4_bench.rs

@@ -0,0 +1,35 @@
+[package]
+name = "generic-btree"
+version = "0.10.7"
+edition = "2021"
+authors = ["zxch3n <remch183@outlook.com>"]
+description = "Generic BTree for versatile purposes"
+homepage = "https://github.com/loro-dev/generic-btree"
+documentation = "https://docs.rs/generic-btree"
+readme = "README.md"
+keywords = ["btree", "data-structure"]
+license = "MIT"
+repository = "https://github.com/loro-dev/generic-btree"
+
+# Vendored into the loro workspace (fork of crates.io generic-btree 0.10.7) so we
+# can evolve the b-tree (e.g. deferred cache propagation). Redirected from
+# crates.io via [patch.crates.io] in the root Cargo.toml.
+
+[features]
+test = []
+
+[lib]
+name = "generic_btree"
+path = "src/lib.rs"
+
+[dependencies]
+arref = "0.1.0"
+heapless = "0.9.1"
+itertools = "0.11.0"
+proc-macro2 = "1.0.67"
+rustc-hash = "2.1.1"
+thunderdome = { version = "0.6.2", package = "loro-thunderdome" }
+
+[dev-dependencies]
+arbitrary = { version = "1", features = ["derive"] }
+rand = "0.8.5"