@@ -0,0 +1,12 @@
+---
+"loro-crdt": patch
+"loro.js": patch
+---
+
+Fix `UndoManager.undo()` and `redo()` consuming additional history items when the top item becomes a no-op after remote edits. Each call now consumes at most one recorded item, preserving unrelated edits and parent containers for subsequent calls. This also applies to Rust `UndoManager::undo()` and `redo()`.
+
+A consumed no-op returns `false` and creates no opposite-stack item. Check `canUndo()` / `canRedo()` (Rust: `can_undo()` / `can_redo()`) for remaining history instead of treating `false` as an empty stack. Grouping and the merge interval still define one history item.
+
+Align loro.js `UndoManager.undo()` and `redo()` with this result: consuming a no-op returns `false` rather than reporting a change. The item is still consumed and other history remains available.
+
+Record local commits whose operations cancel in the state diff as undo items in loro.js, so undo consumes that no-op instead of reverting an earlier item. Public state subscriptions remain silent for empty diffs.
@@ -18,6 +18,8 @@ Loro is a Rust CRDT workspace with JS/WASM packaging and a MoonBit codec.
 
 ## Context Index
 
+- Undo/redo item boundaries when remote edits make an inverse a no-op:
+  [context/undo-history-boundaries.md](context/undo-history-boundaries.md).
 - Encoding/import/export modes, current vs outdated formats, shallow snapshots:
   [context/internal-encoding.md](context/internal-encoding.md).
 - Mergeable container model, marker/cid rules, tests, and common pitfalls:
 
@@ -0,0 +1,49 @@
+# Undo/redo history boundaries
+
+Verified against code 2026-10-17.
+
+`crates/loro-internal/src/undo.rs`: `UndoManager::perform` processes at most
+one recorded `StackItem` per call to `undo` or `redo`. Grouping and the merge
+interval can put several edits, including edits to different containers, into
+that one item.
+
+Remote edits can make the item's transformed inverse a no-op. For example,
+inserting a MovableList element locally and then moving it remotely can cancel
+the positional inverse delete. That item's lack of generated operations must
+not cause `perform` to pop another item: the next item may create an unrelated
+parent container, which would then disappear in the same undo call (#1183).
+
+A consumed no-op still runs the existing `on_pop` and cursor bookkeeping. It
+returns `false`, generates no opposite-stack entry, and leaves other items for
+later calls. Callers must check `can_undo` / `can_redo` to decide whether history
+remains. The public Rust and WASM wrappers share this implementation.
+
+`loro-js/src/runtime/undo.ts`: `UndoManager.undo` and `redo` also consume one
+item. Their result is whether `#invert` produced an opposite-stack item, not
+whether an item was popped. An empty inverse returns `false` while preserving
+pop callbacks, tracked-range cleanup and the remaining history.
+
+`LoroDoc._subscribeUndo` in `loro-js/src/runtime/document.ts` also delivers
+local commits with empty state diffs to the manager, while public state
+subscriptions remain silent. Without this notification, a local MovableList
+insertion and deletion grouped into one item is never recorded, and undo
+instead consumes an earlier item. This is the `insert/delete undo (one peer)`
+differential profile, seed 2, step 33; changing the boolean return alone does
+not fix it. The subscription cleanup removes both listeners.
+
+This boundary rule does not change MovableList identity/anchor transformation,
+grouping, or error handling. In particular, it does not force an inverse that
+has become empty to delete a remotely moved element.
+
+Regressions:
+
+- `crates/loro/tests/integration_test/undo_test.rs`: `noop_history_boundaries`
+  covers undo before a scalar edit or parent creation, redo before a parent
+  creation, unchanged versions for no-ops, subsequent history and convergence.
+- `crates/loro-internal/tests/undo.rs`:
+  `consecutive_noops_consume_one_item_and_notify_once` covers multiple no-ops
+  and one pop callback per item.
+- `crates/loro-wasm/tests/undo.test.ts` covers the exposed JS methods.
+- `loro-js/tests/undo-noop.test.ts` covers no-op undo and redo return values,
+  unchanged versions/frontiers, pop callbacks, subsequent parent history and
+  notification cleanup when the manager is destroyed.
@@ -7,6 +7,8 @@ over graceful degradation.
 
 ## Internal Map
 
+- `src/undo.rs`: one recorded item per undo/redo call, including no-ops:
+  [../../context/undo-history-boundaries.md](../../context/undo-history-boundaries.md).
 - `src/loro.rs`: document-level orchestration for commit, import/export,
   checkout, barriers, state/oplog coordination, and event emission.
   `apply_diff`/`revert_to` roll a failed batch back:
 
@@ -826,6 +826,9 @@ impl UndoManager {
         Ok(())
     }
 
+    /// Consume at most one undo item, even if its transformed inverse is a no-op.
+    /// Returns whether local operations were generated; use `can_undo` to check
+    /// whether history remains after a `false` result.
     #[instrument(skip_all)]
     pub fn undo(&self) -> LoroResult<bool> {
         self.perform(
@@ -835,6 +838,8 @@ impl UndoManager {
         )
     }
 
+    /// Consume at most one redo item, including a no-op. A `false` result means
+    /// no local operations were generated, not necessarily an empty redo stack.
     #[instrument(skip_all)]
     pub fn redo(&self) -> LoroResult<bool> {
         self.perform(
@@ -909,7 +914,7 @@ impl UndoManager {
         // rather than using the current selection directly.
         self.record_new_checkpoint()?;
         let end_counter = get_counter_end(doc, self.peer());
-        let mut top = {
+        let top = {
             let lock = self.inner.lock();
             let mut inner = lock.borrow_mut();
             inner.processing_undo = true;
@@ -920,7 +925,9 @@ impl UndoManager {
         };
 
         let mut executed = false;
-        while let Some((mut span, remote_diff)) = top {
+        // A no-op still consumes this item. Never cross its history boundary
+        // to undo/redo an unrelated edit in the same call.
+        if let Some((mut span, remote_diff)) = top {
             let mut next_push_selection = None;
             {
                 let inner = self.inner.clone();
@@ -1018,11 +1025,6 @@ impl UndoManager {
                     .push(CounterSpan::new(end_counter, new_counter), meta);
                 inner.borrow_mut().next_counter = Some(new_counter);
                 executed = true;
-                break;
-            } else {
-                // continue to pop the undo item as this undo is a no-op
-                top = get_stack(&mut self.inner.lock().borrow_mut()).pop();
-                continue;
             }
         }
 
 
@@ -4,6 +4,56 @@ use loro_internal::{
     cursor::PosType, handler::UpdateOptions, loro::ExportMode, LoroDoc, UndoManager,
 };
 
+#[test]
+fn consecutive_noops_consume_one_item_and_notify_once() {
+    use std::sync::{
+        atomic::{AtomicUsize, Ordering},
+        Arc,
+    };
+
+    let doc = LoroDoc::new_auto_commit();
+    doc.set_peer_id(1).unwrap();
+    let undo = UndoManager::new(&doc);
+    undo.set_merge_interval(0);
+    let pops = Arc::new(AtomicUsize::new(0));
+    let popped = pops.clone();
+    undo.set_on_pop(Some(Box::new(move |_, _, _| {
+        popped.fetch_add(1, Ordering::Relaxed);
+    })));
+    doc.get_map("map").insert("prior", 42).unwrap();
+    doc.commit_then_renew();
+    let text = doc.get_text("text");
+    text.insert(0, "a", PosType::Unicode).unwrap();
+    doc.commit_then_renew();
+    text.insert(1, "b", PosType::Unicode).unwrap();
+    doc.commit_then_renew();
+
+    let other = LoroDoc::from_snapshot(&doc.export(ExportMode::Snapshot).unwrap()).unwrap();
+    other.set_peer_id(2).unwrap();
+    other
+        .get_text("text")
+        .delete(0, 2, PosType::Unicode)
+        .unwrap();
+    doc.import(&other.export(ExportMode::all_updates()).unwrap())
+        .unwrap();
+    let before = doc.get_deep_value();
+    assert_eq!(undo.undo_count(), 3);
+    for remaining in [2, 1] {
+        assert!(!undo.undo().unwrap());
+        assert_eq!(undo.undo_count(), remaining);
+        assert_eq!(undo.redo_count(), 0);
+        assert_eq!(pops.load(Ordering::Relaxed), 3 - remaining);
+        assert_eq!(doc.get_deep_value(), before);
+    }
+    assert!(undo.undo().unwrap());
+    assert_eq!(pops.load(Ordering::Relaxed), 3);
+    assert!(!undo.can_undo());
+    assert!(!undo.undo().unwrap());
+    assert_eq!(pops.load(Ordering::Relaxed), 3);
+    assert!(undo.redo().unwrap());
+    assert_eq!(doc.get_deep_value(), before);
+}
+
 #[test]
 fn test_basic_undo_group_checkpoint() {
     let doc = LoroDoc::new();
 
@@ -5721,6 +5721,11 @@ impl UndoManager {
 
     /// Undo the last operation.
     ///
+    /// Consumes at most one history item, as defined by grouping and the merge
+    /// interval. Returns whether local operations were generated. A no-op item
+    /// is consumed and returns false without undoing earlier items. Use
+    /// `canUndo()` to check whether history remains.
+    ///
     /// Throws without changing the doc if the step would have to recreate a
     /// container of a type unknown to this version (created by a newer
     /// loro-crdt). That step, with every edit merged into it, is dropped and its
@@ -5733,6 +5738,10 @@ impl UndoManager {
 
     /// Redo the last undone operation.
     ///
+    /// Consumes at most one history item, including a no-op. Returns whether
+    /// local operations were generated. A false result does not imply that the
+    /// redo stack is empty; use `canRedo()` to check for remaining history.
+    ///
     /// Throws like `undo` on steps that would recreate a container of an
     /// unknown type.
     pub fn redo(&mut self) -> JsResult<bool> {
 
@@ -1,8 +1,80 @@
-import { Cursor, LoroDoc, UndoManager } from "../bundler/index";
+import { Cursor, LoroDoc, LoroMap, UndoManager } from "../bundler/index";
 import { describe, expect, test } from "vitest";
 import { expectDefined } from "./helpers";
 
 describe("undo", () => {
+  test.each([false, true])(
+    "no-op undo preserves an earlier item (parent=%s)",
+    (parent) => {
+      const doc = new LoroDoc();
+      doc.setPeerId(1);
+      const list = doc.getMovableList("list");
+      list.insert(0, 1);
+      list.insert(1, 2);
+      doc.commit();
+      const remote = new LoroDoc();
+      remote.setPeerId(2);
+      remote.import(doc.export({ mode: "snapshot" }));
+      const undo = new UndoManager(doc, { mergeInterval: 0 });
+      const root = doc.getMap("root");
+      if (parent) {
+        root.setContainer("prior", new LoroMap()).set("value", 42);
+      } else {
+        root.set("prior", 42);
+      }
+      doc.commit();
+      list.insert(0, 0);
+      doc.commit();
+      remote.import(doc.export({ mode: "update" }));
+      remote.getMovableList("list").move(0, 2);
+      remote.commit();
+      doc.import(remote.export({ mode: "update" }));
+
+      const before = doc.toJSON();
+      expect(undo.undo()).toBe(false);
+      expect(doc.toJSON()).toEqual(before);
+      expect(undo.canUndo()).toBe(true);
+      expect(undo.canRedo()).toBe(false);
+      expect(undo.undo()).toBe(true);
+      expect(root.get("prior")).toBeUndefined();
+      expect(undo.redo()).toBe(true);
+      expect(doc.toJSON()).toEqual(before);
+    },
+  );
+
+  test("no-op redo preserves a later parent creation", () => {
+    const doc = new LoroDoc();
+    doc.setPeerId(1);
+    const list = doc.getMovableList("list");
+    list.insert(0, 1);
+    list.insert(1, 2);
+    doc.commit();
+    const undo = new UndoManager(doc, { mergeInterval: 0 });
+    list.delete(0, 1);
+    doc.commit();
+    const root = doc.getMap("root");
+    root.setContainer("parent", new LoroMap());
+    doc.commit();
+    expect(undo.undo()).toBe(true);
+    expect(undo.undo()).toBe(true);
+    const remote = new LoroDoc();
+    remote.setPeerId(2);
+    remote.import(doc.export({ mode: "snapshot" }));
+    remote.getMovableList("list").move(0, 1);
+    remote.commit();
+    doc.import(remote.export({ mode: "update" }));
+
+    const before = doc.toJSON();
+    expect(undo.redo()).toBe(false);
+    expect(doc.toJSON()).toEqual(before);
+    expect(undo.canRedo()).toBe(true);
+    expect(undo.canUndo()).toBe(false);
+    expect(undo.redo()).toBe(true);
+    expect(root.get("parent")).toBeDefined();
+    expect(undo.undo()).toBe(true);
+    expect(doc.toJSON()).toEqual(before);
+  });
+
   test("basic text undo", () => {
     const doc = new LoroDoc();
     doc.setPeerId(1);
 
@@ -4045,6 +4045,11 @@ impl UndoManager {
 
     /// Undo the last change made by the peer.
     ///
+    /// Consumes at most one history item, as defined by grouping and the merge
+    /// interval. Returns whether local operations were generated. An item that
+    /// has become a no-op is consumed and returns `Ok(false)` without undoing
+    /// earlier items. Use [`Self::can_undo`] to check whether history remains.
+    ///
     /// Returns `Err(LoroError::ArgErr)` without changing the doc if the step
     /// would have to recreate a container of a type unknown to this version
     /// (written by a newer Loro). That step is dropped and its edits stay; the
@@ -4056,6 +4061,10 @@ impl UndoManager {
 
     /// Redo the last change made by the peer.
     ///
+    /// Consumes at most one history item, including a no-op. Returns whether
+    /// local operations were generated; `Ok(false)` does not imply the redo
+    /// stack is empty. See [`Self::can_redo`].
+    ///
     /// Fails like [`UndoManager::undo`] on steps that would recreate a
     /// container of an unknown type.
     pub fn redo(&mut self) -> LoroResult<bool> {