fix(loro.js): model MovableList like Rust (positions and LWW elements)

.changeset/loro-js-movable-list-model.md

@@ -0,0 +1,20 @@
+---
+"loro.js": minor
+---
+
+`LoroMovableList` now follows Rust's model: list items (positions) and elements are separate, and an element's position and value are last-writer-wins registers. This fixes convergence with Rust and `loro-crdt`:
+
+- A move of an element that another peer deleted concurrently keeps the element (`["a","c","B"]`, as in Rust), and a delete after a move removes the moved element.
+- Snapshots write and read Rust's MovableList layout, including list item IDs, element IDs, last-set IDs and dead list items. Before, loro.js wrote every position and last-set ID as the element ID.
+- `getLastEditorAt` and `getLastMoverAt` return the last setter and mover instead of the creator.
+- Checkout, `diff`, `revertTo`, `applyDiff` and undo select winners the way Rust does. Undoing a `move` or `set` reinserts the old value, and undo transforms its inverse only over changes the `UndoManager` did not make, as Rust's does.
+- `set` records an op even when the value is unchanged, and `move(i, i)` is a no-op, as in Rust. `getIdAt` and `getCursor` of a MovableList anchor the list item, like Rust's cursor.
+- Importing concurrent moves resolves their indices incrementally, like Rust's tracker, instead of one causal view per op.
+
+Also fixed while making loro.js match Rust:
+
+- A document loaded from a snapshot rebuilds each container that an import touches concurrently with the snapshot from that container's history first (as a checkout already does), so List, Text and MovableList place such changes where Rust does (loro-dev/loro#1163). A MovableList snapshot takes part in this completion like Text and List.
+- Changes imported as pending while a snapshot's history was still undecoded were lost once the history was decoded (for example by a checkout or a history query); they now stay pending.
+- Shallow documents follow Rust's rule for outdated imports: they accept changes rooted at the empty version when the shallow root is empty, skip changes already inside the shallow root, and reject a change whose part after the root depends on trimmed history. A shallow snapshot rooted at a peer's first op now writes the start version that Rust expects.
+- An import that only adds pending changes creates the root containers they edit, as Rust does.
+- Importing a shallow snapshot emits events for containers that exist only in the shallow root state.

context/loro-js-differential-fuzz.md

@@ -1,6 +1,6 @@
 # loro.js Differential Fuzzing
 
-Verified against code 2026-09-29.
+Verified against code 2026-09-30.
 
 `loro-js/tests/fuzz/differential.ts` drives several `loro.js` peers through
 random edits, update exchanges, and checkouts, and checks them against
@@ -76,8 +76,9 @@ prints each action as it runs, which finds hangs. The report groups failures by
 signature (oracle plus first differing root or normalized error) and stores the
 minimized action list and a trace written as `loro.js` API calls.
 
-CI runs 120 fixed seeds of Map/List/Text/Counter, and 120 more with nested
-child containers and snapshot imports, with the replay, checkout,
+CI runs 120 fixed seeds of Map/List/Text/Counter, 120 with MovableList and
+nested child containers, and 120 more with nested child containers and snapshot
+imports, with the replay, checkout,
 full-snapshot, and event oracles. A seed that fails on `main` for a known
 reason goes into `pending` with that reason until its fix lands; both lists are
 empty on 2026-09-29 (`main` at #1131).
@@ -98,6 +99,13 @@ re-inserts (#1150). With nested children and snapshot imports, seeds 297,
 315, 344, 422, 452, and 559 of 0–599 fail on `main` in the event oracle;
 #1150 fixes all six.
 
+MovableList, fixed by the Rust-model rewrite (loro-dev/loro#1132 and its
+follow-ups, see [loro-js-movable-list.md](loro-js-movable-list.md)): with
+`FUZZ_FEATURES=map,list,text,counter,movableList,nested`, all oracles and
+lockstep with Rust, 144 of seeds 0–299 failed on `main` on 2026-09-30 (98
+checkout-vs-replay, 29 lockstep); on the rewrite seeds 0–599 pass, and CI runs
+120 of them without Rust.
+
 Still open, so `CI_RUNS` does not enable them yet:
 
 - Tree convergence: `loro.js` applies tree moves per node, last writer wins,
@@ -121,8 +129,6 @@ Still open, so `CI_RUNS` does not enable them yet:
   (`DocState::get_path`); `loro.js` still sends them. Needs #1147's liveness.
 - Shallow snapshots in the harness need #1144 (the root check fails first on
   every seed without it).
-- MovableList: `loro.js` skips a movable-list `set` to the current value,
-  which Rust records.
 
 ## Rust-side findings