Struct EphemeralStore 

pub struct EphemeralStore { /* private fields */ }

EphemeralStore is a structure that tracks ephemeral key-value state across peers.

• Use it for syncing lightweight presence/state like cursors, selections, and UI hints.
• Each key uses timestamp-based LWW (Last-Write-Wins) conflict resolution.
• Timeout unit: milliseconds.
• After timeout: entries are considered expired. They are omitted from encode/encode_all, and calling [remove_outdated] will purge them and notify subscribers with EphemeralEventTrigger::Timeout.

In Rust, you are responsible for periodically calling [remove_outdated] if you want timed-out entries to be removed and corresponding events to be emitted. In the WASM/TS wrapper, a timer runs automatically while the store is non-empty.

See: https://loro.dev/docs/tutorial/ephemeral

Example

use loro_internal::awareness::EphemeralStore;

let mut store = EphemeralStore::new(1000);
store.set("key", "value");
let encoded = store.encode("key");
let mut store2 = EphemeralStore::new(1000);
store.subscribe_local_updates(Box::new(|data| {
    println!("local update: {:?}", data);
    true
}));
store2.apply(&encoded);
assert_eq!(store2.get("key"), Some("value".into()));

Implementations

impl EphemeralStore

pub fn new(timeout: i64) -> Self

Create a new EphemeralStore.

• timeout: inactivity timeout in milliseconds. If a key does not receive updates within this duration, it is considered expired. It will be skipped by encode/encode_all, and removed when [remove_outdated] is called (triggering a Timeout event to subscribers).

pub fn encode(&self, key: &str) -> Vec<u8>

Encode the latest value of key.

Expired keys (past timeout) are omitted and produce an empty payload.

pub fn encode_all(&self) -> Vec<u8>

Encode all non-expired keys.

Entries that have exceeded the timeout are not included in the payload.

pub fn apply(&self, data: &[u8]) -> Result<(), Box<str>>

Apply encoded updates imported from another peer/process.

Subscribers receive an event with by = Import and the lists of added/updated/removed keys as appropriate.

pub fn set(&self, key: &str, value: impl Into<LoroValue>)

pub fn delete(&self, key: &str)

pub fn get(&self, key: &str) -> Option<LoroValue>

pub fn remove_outdated(&self)

Remove entries whose last update timestamp has exceeded the timeout.

If any keys are removed, subscribers receive an event with by = Timeout and the removed keys. This does not run automatically in Rust; call it on your own schedule.

pub fn get_all_states(&self) -> FxHashMap<String, LoroValue>

pub fn keys(&self) -> Vec<String>

pub fn subscribe_local_updates( &self, callback: LocalEphemeralCallback, ) -> Subscription

Subscribe to local ephemeral/awareness updates.

The callback receives encoded update bytes whenever local ephemeral state changes. This is useful for syncing awareness information like cursor positions, selections, or presence data to other peers in real-time.

Auto-unsubscription: If the callback returns false, the subscription will be automatically removed, providing a convenient way to implement one-time or conditional subscriptions in Rust.

Parameters

• callback: Function that receives &Vec<u8> (encoded ephemeral updates) and returns bool
  • Return true to keep the subscription active
  • Return false to automatically unsubscribe

Example

use loro_internal::awareness::EphemeralStore;
use std::sync::{Arc, Mutex};

let store = EphemeralStore::new(30000);
let update_count = Arc::new(Mutex::new(0));
let count_clone = update_count.clone();

// Subscribe and collect first 3 updates, then auto-unsubscribe
let sub = store.subscribe_local_updates(Box::new(move |bytes| {
    println!("Received {} bytes of ephemeral data", bytes.len());
    let mut count = count_clone.lock().unwrap();
    *count += 1;
    *count < 3  // Auto-unsubscribe after 3 updates
}));

store.set("cursor", 42);

pub fn subscribe(&self, callback: EphemeralSubscriber) -> Subscription

Trait Implementations

impl Clone for EphemeralStore

fn clone(&self) -> EphemeralStore

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for EphemeralStore

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.