Exporting snapshot exports data incorrectly

[ioder]

Summary

We populate a LoroDoc from a plain JS object using loro-mirror (with defaultMovableList: true). We then try two ways to clone the document:

• JSON-updates round-trip: doc.exportJsonUpdates() → newDoc.importJsonUpdates(...)
• Snapshot round-trip: doc.export({ mode: 'snapshot' }) → LoroDoc.fromSnapshot(...)

Path (1) reproduces the state correctly. Path (2) does not — newDoc.toJSON() differs from doc.toJSON(), even though both methods are documented as full-state exports.

Investigating the snapshot itself in Loro Inspector will reveal that the snapshot is already missing data.

Reproduction

https://codesandbox.io/p/devbox/pxtpmw

import { LoroDoc } from 'loro-crdt'
import { Mirror } from 'loro-mirror'
const state = {
  payload: { title: 'hello', count: 42 },
  items: [
    { id: 'a', value: 1 },
    { id: 'b', value: 2 },
  ],
}
const doc = toLoroDoc(state)
console.log('Original document JSON', doc.toJSON())

// (1) clone via JSON updates
const updates = doc.exportJsonUpdates()
const newDoc = new LoroDoc()
newDoc.importJsonUpdates(updates)
console.log('Copy via JSON updates', newDoc.toJSON())   // <-- matches original

// (2) clone via snapshot
const snapshot = doc.export({ mode: 'snapshot' })
const newDoc2 = LoroDoc.fromSnapshot(snapshot)
console.log('Copy via snapshot', newDoc2.toJSON())      // <-- diverges from original

function toLoroDoc(state: any): LoroDoc {
  const doc = new LoroDoc()
  doc.setRecordTimestamp(true)
  const mirror = createLoroMirror({ doc, initialState: state })
  mirror.setState(() => state)
  return doc
}
function createLoroMirror(options: any): any {
  const { initialState, inferOptions } = options
  return new Mirror({
    ...options,
    initialState: emptyRootShape(initialState ?? {}),
    inferOptions: { ...inferOptions, defaultMovableList: true },
    validateUpdates: false,
  })
}
function emptyRootShape(document: any): any {
  return Object.fromEntries(
    Object.entries(document).map(([key, value]) => {
      if (Array.isArray(value)) return [key, []]
      if (!!value && typeof value === 'object') return [key, {}]
      return [key, value]
    }),
  )
}

Expected

After mirror.setState, the doc has a full operation history describing every container creation, map insertion, and list insertion. doc.export({ mode: 'snapshot' }) is documented as it should be exporting all changes, LoroDoc.fromSnapshot(...) should return document with whole state.

Environment

loro-crdt version: 1.12.0
loro-mirror version: 2.1.0
Node version: 22.22.0

[ioder]

@zxch3n, is there any possibility of releasing this extremely quick fix? I'm a bit stuck on a project and don't have a proper workaround.

[zxch3n]

I will release it soon.

This was caused by same-name root containers with different container types.

In this case, loro-mirror first pre-created items as an empty root List from the initial empty shape, but later, because defaultMovableList: true was enabled, it wrote the real data into a root MovableList with the same name:

doc.getList("items");        // empty root List
doc.getMovableList("items"); // non-empty root MovableList

Internally these are different root containers, but toJSON() / get_deep_value() expose root containers as a JSON object keyed only by the root name. So after snapshot import, the empty List could overwrite the non-empty MovableList in the visible JSON result, producing items: [].

loro-mirror fixed its side in loro-dev/loro-mirror#81 by respecting defaultMovableList during root initialization, so it should no longer create the wrong empty root List before writing to the MovableList.

On the Loro side, I added a defensive fix in #973: when reading root values, path lookups, or JSONPath, if multiple root containers have the same name but different container types, Loro now prefers the non-empty root container. This prevents an empty same-name root from hiding the real non-empty root state after snapshot roundtrips or similar legacy/corrupted states.

So the root cause was in loro-mirror, but Loro now handles this ambiguous state more robustly too.