chore: release rust crates v1.17.1

.changeset/restore-state-vv-signature.md

@@ -0,0 +1,9 @@
+---
+"loro-crdt": patch
+---
+
+Restore the Rust `LoroDoc::state_vv()` return type to `VersionVector`, preserving
+source compatibility with versions before 1.17.0. Keep `try_state_vv()` as the
+fallible API for callers that need to handle unreadable history. The legacy
+method panics on resolution failure after releasing the document locks. WASM
+`version()` continues to return readable errors through the fallible API.

context/arena-parent-links.md

@@ -1,6 +1,6 @@
 # Arena Parent Links
 
-Verified against code 2026-10-09.
+Verified against code 2026-10-22.
 
 `SharedArena` (`crates/loro-internal/src/arena.rs`) stores each container's
 parent. Liveness (`DocState::is_deleted`), paths (`DocState::get_path`,
@@ -161,9 +161,12 @@ already recorded failures, and their history reads also propagate failures
   `try_state_vv`, `try_export_json_updates`, and `try_get_cursor_pos` to
   receive decode errors. `state_vv` clones `OpLog::vv` when the state and op
   log frontiers are equal; that vector is cached and does not parse block
-  bodies. Otherwise it uses `try_frontiers_to_vv`, and returns
+  bodies. Otherwise it uses `try_frontiers_to_vv`. `try_state_vv` returns
   `FrontiersNotFound` when a frontier id is absent rather than an empty
-  version vector. `cmp_frontiers` keeps its `FrontiersNotIncluded` error type,
+  version vector. `state_vv` preserves its pre-1.17 infallible signature and
+  panics on resolution failure, after releasing the document locks. Rust
+  callers handling untrusted history should use `try_state_vv`; WASM `version()`
+  continues using that fallible path. `cmp_frontiers` keeps its `FrontiersNotIncluded` error type,
   which can now carry the decode-error message; `travel_change_ancestors`
   returns `ChangeTravelError::HistoryUnreadable(LoroError::DecodeError(..))`.
   `ChangeTravelError` is now non-exhaustive, so downstream matches need a

crates/loro-internal/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "loro-internal"
-version = "1.17.0"
+version = "1.17.1"
 edition = "2021"
 license = "MIT"
 description = "Loro internal library. Do not use it directly as it's not stable."

crates/loro-internal/VERSION

@@ -1 +1 @@
-1.17.0
+1.17.1

crates/loro-internal/src/loro.rs

@@ -1187,12 +1187,19 @@ impl LoroDoc {
     /// When the state frontiers are the op-log frontiers, this clones the cached
     /// op-log version vector and does not parse change blocks. Otherwise it
     /// walks the frontiers.
+    ///
+    /// # Panics
+    ///
+    /// Panics if the state's version cannot be resolved from the document history.
+    /// Use [`Self::try_state_vv`] to handle unreadable history as an error.
     #[inline]
-    pub fn state_vv(&self) -> LoroResult<VersionVector> {
+    pub fn state_vv(&self) -> VersionVector {
         self.try_state_vv()
+            .expect("Cannot resolve the state version vector")
     }
 
-    /// [`state_vv`](Self::state_vv), including a decode error from unreadable history.
+    /// Get the version vector of the current state, returning a decode error
+    /// when required history cannot be read.
     ///
     /// `Ok(None)` from the frontier walk (the frontiers are not in the dag) is
     /// [`LoroError::FrontiersNotFound`] for an id that can be named, not an empty

crates/loro-internal/tests/undo.rs

@@ -121,7 +121,7 @@ fn test_simulate_intersecting_remote_undo() {
     let snapshot = doc.export(ExportMode::Snapshot).unwrap();
     let doc2 = LoroDoc::from_snapshot(&snapshot).unwrap();
     let text2 = doc2.get_text("text");
-    let vv = doc2.state_vv().unwrap();
+    let vv = doc2.state_vv();
     text2.update("123", UpdateOptions::default()).unwrap();
     doc2.commit_then_renew();
 
@@ -164,7 +164,7 @@ fn test_simulate_non_intersecting_remote_undo() {
     // The doc 2 has state of "123" in the "text2" container
     let doc2 = LoroDoc::from_snapshot(&snapshot).unwrap();
     let text2 = doc2.get_text("text2");
-    let vv = doc2.state_vv().unwrap();
+    let vv = doc2.state_vv();
     text2.update("123", UpdateOptions::default()).unwrap();
     doc2.commit_then_renew();
     let update = doc2

crates/loro/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "loro"
-version = "1.17.0"
+version = "1.17.1"
 edition = "2021"
 license = "MIT"
 documentation = "https://docs.rs/loro/"
@@ -14,7 +14,7 @@ keywords = ["crdt", "local-first"]
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-loro-internal = { path = "../loro-internal", version = "1.17.0" }
+loro-internal = { path = "../loro-internal", version = "1.17.1" }
 loro-common = { path = "../loro-common", version = "1.17.0", features = [
     "serde_json",
 ] }

crates/loro/src/lib.rs

@@ -998,15 +998,20 @@ impl LoroDoc {
     ///
     /// When the state is at the op-log frontiers this clones the cached op-log
     /// version vector and does not parse change blocks. Otherwise it walks the
-    /// frontiers. A change block that cannot be parsed is [`LoroError::DecodeError`].
-    /// Frontiers that are not in the dag are [`LoroError::FrontiersNotFound`] when
-    /// an id can be named, not an empty version vector.
+    /// frontiers.
+    ///
+    /// # Panics
+    ///
+    /// Panics if the state's version cannot be resolved from the document history.
+    /// Use [`Self::try_state_vv`] to handle unreadable history as an error.
     #[inline]
-    pub fn state_vv(&self) -> LoroResult<VersionVector> {
-        self.try_state_vv()
+    pub fn state_vv(&self) -> VersionVector {
+        self.doc.state_vv()
     }
 
-    /// [`state_vv`](Self::state_vv).
+    /// Get the `VersionVector` version of `DocState`, returning an error if the
+    /// required history cannot be read or a state frontier is missing.
+    /// Unreadable history produces [`LoroError::DecodeError`].
     #[inline]
     pub fn try_state_vv(&self) -> LoroResult<VersionVector> {
         self.doc.try_state_vv()

crates/loro/tests/integration_test/detached_editing_test.rs

@@ -64,13 +64,13 @@ fn allow_editing_on_detached_mode_when_detached_editing_is_enabled() {
     assert_eq!(doc.get_text("text").to_string(), "Hello alice!");
     assert_eq!(&**string.lock().unwrap(), "Hello alice!");
     assert_ne!(doc.state_frontiers(), doc.oplog_frontiers());
-    assert_ne!(doc.oplog_vv(), doc.state_vv().unwrap());
+    assert_ne!(doc.oplog_vv(), doc.state_vv());
     assert_eq!(doc.state_frontiers(), Frontiers::from(ID::new(2, 6)));
     assert_eq!(
         doc.oplog_frontiers(),
         Frontiers::from([ID::new(1, 11), ID::new(2, 6)])
     );
-    assert_eq!(doc.state_vv().unwrap(), vv!(1 => 5, 2 => 7));
+    assert_eq!(doc.state_vv(), vv!(1 => 5, 2 => 7));
     assert_eq!(doc.oplog_vv(), vv!(1 => 12, 2 => 7));
 
     doc.checkout_to_latest();
@@ -82,7 +82,7 @@ fn allow_editing_on_detached_mode_when_detached_editing_is_enabled() {
     assert_eq!(doc.get_text("text").to_string(), "Hello world! alice!");
     assert_eq!(&**string.lock().unwrap(), "Hello world! alice!");
     assert_eq!(doc.state_frontiers(), doc.oplog_frontiers());
-    assert_eq!(doc.oplog_vv(), doc.state_vv().unwrap());
+    assert_eq!(doc.oplog_vv(), doc.state_vv());
 
     // New op on peer id 1
     doc.set_peer_id(1).unwrap();
@@ -91,7 +91,7 @@ fn allow_editing_on_detached_mode_when_detached_editing_is_enabled() {
     assert_eq!(&**string.lock().unwrap(), "Hi Hello world! alice!");
     assert_eq!(doc.get_text("text").to_string(), "Hi Hello world! alice!");
     assert_eq!(doc.state_frontiers(), doc.oplog_frontiers());
-    assert_eq!(doc.oplog_vv(), doc.state_vv().unwrap());
+    assert_eq!(doc.oplog_vv(), doc.state_vv());
     assert_eq!(doc.state_frontiers(), Frontiers::from_id(ID::new(1, 14)));
     let json = doc
         .export_json_updates(&Default::default(), &doc.oplog_vv())
@@ -222,13 +222,13 @@ fn allow_editing_on_detached_mode_when_detached_editing_is_enabled_2() {
     assert_eq!(doc.get_text("text").to_string(), "Hello alice!");
     assert_eq!(&**string.lock().unwrap(), "Hello alice!");
     assert_ne!(doc.state_frontiers(), doc.oplog_frontiers());
-    assert_ne!(doc.oplog_vv(), doc.state_vv().unwrap());
+    assert_ne!(doc.oplog_vv(), doc.state_vv());
     assert_eq!(doc.state_frontiers(), Frontiers::from(ID::new(0, 6)));
     assert_eq!(
         doc.oplog_frontiers(),
         Frontiers::from([ID::new(1, 11), ID::new(0, 6)])
     );
-    assert_eq!(doc.state_vv().unwrap(), vv!(1 => 5, 0 => 7));
+    assert_eq!(doc.state_vv(), vv!(1 => 5, 0 => 7));
     assert_eq!(doc.oplog_vv(), vv!(1 => 12, 0 => 7));
 
     doc.checkout_to_latest();
@@ -240,7 +240,7 @@ fn allow_editing_on_detached_mode_when_detached_editing_is_enabled_2() {
     assert_eq!(doc.get_text("text").to_string(), "Hello alice! world!");
     assert_eq!(&**string.lock().unwrap(), "Hello alice! world!");
     assert_eq!(doc.state_frontiers(), doc.oplog_frontiers());
-    assert_eq!(doc.oplog_vv(), doc.state_vv().unwrap());
+    assert_eq!(doc.oplog_vv(), doc.state_vv());
 }
 
 #[test]

crates/loro/tests/integration_test/shallow_snapshot_test.rs

@@ -341,8 +341,8 @@ fn the_vv_on_shallow_doc() -> anyhow::Result<()> {
     let new_doc = LoroDoc::new();
     new_doc.import(&snapshot.unwrap()).unwrap();
     assert!(!new_doc.shallow_since_vv().is_empty());
-    assert_eq!(new_doc.oplog_vv(), new_doc.state_vv().unwrap());
-    assert_eq!(new_doc.oplog_vv(), doc.state_vv().unwrap());
+    assert_eq!(new_doc.oplog_vv(), new_doc.state_vv());
+    assert_eq!(new_doc.oplog_vv(), doc.state_vv());
     assert_eq!(new_doc.oplog_frontiers(), doc.oplog_frontiers());
     assert_eq!(new_doc.oplog_frontiers(), new_doc.state_frontiers());
     assert_eq!(new_doc.get_deep_value(), doc.get_deep_value());
@@ -351,8 +351,8 @@ fn the_vv_on_shallow_doc() -> anyhow::Result<()> {
     doc.commit();
     let bytes = doc.export(ExportMode::all_updates());
     new_doc.import(&bytes.unwrap()).unwrap();
-    assert_eq!(new_doc.oplog_vv(), new_doc.state_vv().unwrap());
-    assert_eq!(new_doc.oplog_vv(), doc.state_vv().unwrap());
+    assert_eq!(new_doc.oplog_vv(), new_doc.state_vv());
+    assert_eq!(new_doc.oplog_vv(), doc.state_vv());
     assert_eq!(new_doc.oplog_frontiers(), doc.oplog_frontiers());
     assert_eq!(new_doc.oplog_frontiers(), new_doc.state_frontiers());
     assert_eq!(new_doc.get_deep_value(), doc.get_deep_value());

crates/loro/tests/loro_rust_test.rs

@@ -1278,7 +1278,7 @@ fn sync_two_shallow_docs() {
     assert_eq!(doc_a.get_deep_value(), doc_b.get_deep_value());
     assert_eq!(doc_a.oplog_vv(), doc_b.oplog_vv());
     assert_eq!(doc_a.oplog_frontiers(), doc_b.oplog_frontiers());
-    assert_eq!(doc_a.state_vv().unwrap(), doc_b.state_vv().unwrap());
+    assert_eq!(doc_a.state_vv(), doc_b.state_vv());
     assert_eq!(doc_a.shallow_since_vv(), doc_b.shallow_since_vv());
 }
 
@@ -2092,7 +2092,7 @@ fn issue_490() -> anyhow::Result<()> {
 fn test_loro_doc() {
     let doc = LoroDoc::new();
     doc.get_text("text").insert(0, "Hello").unwrap();
-    doc.state_vv().unwrap();
+    doc.state_vv();
 }
 
 #[test]

crates/loro/tests/state_version.rs

@@ -0,0 +1,32 @@
+use loro::{ExportMode, LoroDoc, VersionVector};
+
+#[test]
+fn state_vv_keeps_its_infallible_signature_and_tracks_checked_out_state() {
+    // Downstream code written before 1.17.0 must continue compiling.
+    let state_vv: fn(&LoroDoc) -> VersionVector = LoroDoc::state_vv;
+    let source = LoroDoc::new();
+    source.set_peer_id(1).unwrap();
+    source.get_text("text").insert(0, "a").unwrap();
+    source.commit();
+    let earlier_frontiers = source.state_frontiers();
+    let earlier_vv = state_vv(&source);
+    source.get_text("text").insert(1, "b").unwrap();
+    let snapshot = source.export(ExportMode::Snapshot).unwrap();
+
+    let doc = LoroDoc::new();
+    doc.import(&snapshot).unwrap();
+    let latest_vv = doc.oplog_vv();
+    assert_ne!(earlier_vv, latest_vv);
+    assert_eq!(state_vv(&doc), latest_vv);
+    assert_eq!(doc.try_state_vv().unwrap(), latest_vv);
+
+    doc.checkout(&earlier_frontiers).unwrap();
+    assert_eq!(doc.get_text("text").to_string(), "a");
+    assert_eq!(state_vv(&doc), earlier_vv);
+    assert_eq!(doc.try_state_vv().unwrap(), earlier_vv);
+    assert_eq!(doc.oplog_vv(), latest_vv);
+
+    doc.checkout_to_latest();
+    assert_eq!(state_vv(&doc), latest_vv);
+    assert_eq!(doc.try_state_vv().unwrap(), latest_vv);
+}

crates/loro/tests/unparsable_history.rs

@@ -59,7 +59,7 @@ fn state_vv_of_the_fixture_uses_the_cached_oplog_vv() {
     let doc = LoroDoc::new();
     doc.import(FIXTURE).unwrap();
     assert_eq!(doc.state_frontiers(), doc.oplog_frontiers());
-    let vv = doc.state_vv().unwrap();
+    let vv = doc.state_vv();
     assert_eq!(vv, doc.oplog_vv());
     assert_eq!(doc.try_state_vv().unwrap(), doc.oplog_vv());