fix: EphemeralStore import should ignore timeout entries (#865)

* fix: ephe store import should ignore timeout entries

* chore: changeset

* test: add ephemeral store timeout apply tests

* docs: add eph rust mod docs

Author: zxch3n

.changeset/odd-rings-care.md

@@ -0,0 +1,6 @@
+---
+"loro-crdt": patch
+"loro-crdt-map": patch
+---
+
+fix: EphemeralStore apply should ignore timeout entries #865

crates/loro-internal/src/awareness.rs

@@ -1,3 +1,14 @@
+//! Ephemeral presence utilities.
+//!
+//! `EphemeralStore` is the recommended API: a timestamped, last-write-wins key-value
+//! store for transient presence data (cursors, selections, etc.). It supports:
+//! - Per-key timeouts: expired entries are skipped by `encode`/`encode_all` and removed
+//!   by `remove_outdated`.
+//! - Import/export via `encode`/`apply` for syncing between peers.
+//! - Subscriptions for both local updates (raw bytes to send) and merged updates.
+//!
+//! The legacy `Awareness` type remains for backward compatibility but is deprecated in
+//! favor of `EphemeralStore`.
 use std::sync::atomic::AtomicI64;
 use std::sync::{Arc, Mutex};
 
@@ -416,13 +427,18 @@ impl EphemeralStoreInner {
         let mut added_keys = Vec::new();
         let mut removed_keys = Vec::new();
         let now = get_sys_timestamp() as Timestamp;
+        let timeout = self.timeout.load(std::sync::atomic::Ordering::Relaxed);
         let mut states = self.states.lock().unwrap();
         for EncodedState {
             key,
             value: record,
             timestamp,
         } in peers_info
         {
+            if now - timestamp > timeout {
+                continue;
+            }
+
             match states.get_mut(key) {
                 Some(peer_info) if peer_info.timestamp >= timestamp => {
                     // do nothing
@@ -432,7 +448,7 @@ impl EphemeralStoreInner {
                         key.to_string(),
                         State {
                             state: record.clone(),
-                            timestamp: now,
+                            timestamp,
                         },
                     );
                     match (old, record) {

crates/loro-internal/tests/ephemeral_store.rs

@@ -0,0 +1,59 @@
+use loro_internal::awareness::EphemeralStore;
+use loro_internal::LoroValue;
+use serde::Serialize;
+use std::time::{Duration, SystemTime, UNIX_EPOCH};
+
+#[derive(Serialize)]
+struct WireState {
+    key: String,
+    value: Option<LoroValue>,
+    timestamp: i64,
+}
+
+fn now_ms() -> i64 {
+    SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .unwrap()
+        .as_millis() as i64
+}
+
+#[test]
+fn import_skips_entries_past_timeout() {
+    let store = EphemeralStore::new(100);
+    let stale_timestamp = now_ms() - 500;
+
+    let payload = postcard::to_allocvec(&vec![WireState {
+        key: "stale".into(),
+        value: Some(LoroValue::from(1)),
+        timestamp: stale_timestamp,
+    }])
+    .unwrap();
+
+    store.apply(&payload).unwrap();
+
+    assert!(store.get("stale").is_none());
+    assert!(store.get_all_states().is_empty());
+}
+
+#[test]
+fn import_preserves_remote_timestamp_for_timeout() {
+    let timeout_ms = 100;
+    let store = EphemeralStore::new(timeout_ms);
+    let remote_timestamp = now_ms() - (timeout_ms - 20);
+
+    let payload = postcard::to_allocvec(&vec![WireState {
+        key: "cursor".into(),
+        value: Some(LoroValue::from("v")),
+        timestamp: remote_timestamp,
+    }])
+    .unwrap();
+
+    store.apply(&payload).unwrap();
+    assert_eq!(store.get("cursor"), Some(LoroValue::from("v")));
+
+    std::thread::sleep(Duration::from_millis(40));
+    store.remove_outdated();
+
+    assert!(store.get("cursor").is_none());
+    assert!(store.get_all_states().is_empty());
+}

crates/loro-wasm/src/awareness.rs

@@ -121,7 +121,8 @@ impl AwarenessWasm {
     /// Get the timestamp of the state of a given peer.
     pub fn getTimestamp(&self, peer: JsIntoPeerID) -> JsResult<Option<f64>> {
         let id = js_peer_to_peer(peer.into())?;
-        Ok(self.inner
+        Ok(self
+            .inner
             .get_all_states()
             .get(&id)
             .map(|r| r.timestamp as f64))

crates/loro-wasm/src/lib.rs

@@ -2431,7 +2431,10 @@ fn diff_event_to_js_value(event: DiffEvent, for_json: bool) -> JsResult<JsValue>
 ///   path: Path;
 /// }
 ///
-fn container_diff_to_js_value(event: &loro_internal::ContainerDiff, for_json: bool) -> JsResult<JsValue> {
+fn container_diff_to_js_value(
+    event: &loro_internal::ContainerDiff,
+    for_json: bool,
+) -> JsResult<JsValue> {
     let obj = js_sys::Object::new();
     Reflect::set(&obj, &"target".into(), &event.id.to_string().into())?;
     Reflect::set(