@@ -0,0 +1,11 @@
+---
+"loro-crdt": minor
+---
+
+feat: add APIs to fetch values associated with the top Undo and Redo stack entries (#790)
+
+- JS/WASM: `undo.topUndoValue()` and `undo.topRedoValue()` return the `value` from the top undo/redo item (or `undefined` when empty).
+- Rust: `UndoManager::{top_undo_meta, top_redo_meta, top_undo_value, top_redo_value}` to inspect top-of-stack metadata and values.
+- Internal: stack now supports peeking the top item metadata without mutation.
+
+This enables attaching human-readable labels via `onPush`/`onPop` and retrieving them to keep Undo/Redo menu items up to date.
@@ -305,6 +305,23 @@ impl Stack {
         Stack { stack, size: 0 }
     }
 
+    /// Peek the top-most StackItem's metadata without modifying the stack.
+    ///
+    /// Returns None if the stack is empty.
+    fn peek_top_meta(&self) -> Option<UndoItemMeta> {
+        if self.is_empty() {
+            return None;
+        }
+
+        for (items, _) in self.stack.iter().rev() {
+            if let Some(item) = items.back() {
+                return Some(item.meta.clone());
+            }
+        }
+
+        None
+    }
+
     pub fn pop(&mut self) -> Option<(StackItem, Arc<Mutex<DiffBatch>>)> {
         while self.stack.back().unwrap().0.is_empty() && self.stack.len() > 1 {
             let (_, diff) = self.stack.pop_back().unwrap();
@@ -876,6 +893,26 @@ impl UndoManager {
         self.inner.lock().unwrap().redo_stack.len()
     }
 
+    /// Get the metadata of the top undo stack item, if any.
+    pub fn top_undo_meta(&self) -> Option<UndoItemMeta> {
+        self.inner.lock().unwrap().undo_stack.peek_top_meta()
+    }
+
+    /// Get the metadata of the top redo stack item, if any.
+    pub fn top_redo_meta(&self) -> Option<UndoItemMeta> {
+        self.inner.lock().unwrap().redo_stack.peek_top_meta()
+    }
+
+    /// Get the value associated with the top undo stack item, if any.
+    pub fn top_undo_value(&self) -> Option<LoroValue> {
+        self.top_undo_meta().map(|m| m.value)
+    }
+
+    /// Get the value associated with the top redo stack item, if any.
+    pub fn top_redo_value(&self) -> Option<LoroValue> {
+        self.top_redo_meta().map(|m| m.value)
+    }
+
     pub fn set_on_push(&self, on_push: Option<OnPush>) {
         self.inner.lock().unwrap().on_push = on_push;
     }
 
@@ -1 +1 @@
-1.5.12
+1.6.0
@@ -4858,6 +4858,28 @@ impl UndoManager {
         self.undo.can_redo()
     }
 
+    /// Get the value associated with the top undo stack item, if any.
+    /// Returns `undefined` if there is no undo item.
+    pub fn topUndoValue(&self) -> Option<JsLoroValue> {
+        self.undo
+            .top_undo_value()
+            .map(|v| {
+                let js: JsValue = v.into();
+                js.into()
+            })
+    }
+
+    /// Get the value associated with the top redo stack item, if any.
+    /// Returns `undefined` if there is no redo item.
+    pub fn topRedoValue(&self) -> Option<JsLoroValue> {
+        self.undo
+            .top_redo_value()
+            .map(|v| {
+                let js: JsValue = v.into();
+                js.into()
+            })
+    }
+
     /// The number of max undo steps.
     /// If the number of undo steps exceeds this number, the oldest undo step will be removed.
     pub fn setMaxUndoSteps(&mut self, steps: usize) {
 
@@ -20,6 +20,7 @@ import {
   LoroCounter,
   JsonDiff,
   redactJsonUpdates,
+  UndoManager,
 } from "../bundler/index";
 
 it("basic example", () => {
@@ -145,6 +146,46 @@ describe("map", () => {
   });
 });
 
+it("top undo/redo values", () => {
+  const doc = new LoroDoc();
+  doc.setPeerId(1);
+
+  let lastCommitLabel: string | null = null;
+  let lastPoppedLabel: string | null = null;
+
+  const undo = new UndoManager(doc, {
+    mergeInterval: 0,
+    onPush: (isUndo: boolean) => {
+      // For normal commits (Undo stack), use the label set before commit.
+      // For opposite pushes (Redo stack), reuse the last popped label.
+      const value = isUndo ? lastCommitLabel : lastPoppedLabel;
+      return { value, cursors: [] };
+    },
+    onPop: (_isUndo: boolean, meta: { value: unknown }) => {
+      // Remember last popped label so we can assign it to the opposite stack item.
+      lastPoppedLabel = meta.value as string | null;
+    },
+  });
+
+  // 1st commit
+  doc.getText("text").insert(0, "A");
+  lastCommitLabel = 'Insert "A"';
+  doc.commit();
+  expect(undo.topUndoValue()).toBe('Insert "A"');
+  expect(undo.topRedoValue()).toBe(undefined);
+
+  // 2nd commit
+  doc.getText("text").insert(1, "B");
+  lastCommitLabel = 'Insert "B"';
+  doc.commit();
+  expect(undo.topUndoValue()).toBe('Insert "B"');
+
+  // Undo once: the popped undo label should appear as the redo top value
+  undo.undo();
+  expect(undo.topRedoValue()).toBe('Insert "B"');
+  expect(undo.topUndoValue()).toBe('Insert "A"');
+});
+
 describe("import", () => {
   it("pending and import status", () => {
     const a = new LoroDoc();
 
@@ -3602,6 +3602,26 @@ impl UndoManager {
     pub fn peer(&self) -> PeerID {
         self.0.peer()
     }
+
+    /// Get the metadata of the top undo stack item, if any.
+    pub fn top_undo_meta(&self) -> Option<UndoItemMeta> {
+        self.0.top_undo_meta()
+    }
+
+    /// Get the metadata of the top redo stack item, if any.
+    pub fn top_redo_meta(&self) -> Option<UndoItemMeta> {
+        self.0.top_redo_meta()
+    }
+
+    /// Get the value associated with the top undo stack item, if any.
+    pub fn top_undo_value(&self) -> Option<LoroValue> {
+        self.0.top_undo_value()
+    }
+
+    /// Get the value associated with the top redo stack item, if any.
+    pub fn top_redo_value(&self) -> Option<LoroValue> {
+        self.0.top_redo_value()
+    }
 }
 /// When a undo/redo item is pushed, the undo manager will call the on_push callback to get the meta data of the undo item.
 /// The returned cursors will be recorded for a new pushed undo item.