• JSONPath queries are now RFC 9535 compliant across both Rust and WASM bindings. A new parser, evaluator, and conformance test suite (PR #848, commit 21d13218) unlock richer filters like in and contains while delivering clearer error messages. Thanks @zolero!
• Source maps become first-class in the WASM toolchain. loro-wasm-tools now embeds symbols during bundling (#836) and the new loro-wasm-map package publishes maps next to the runtime bundle (#844), drastically simplifying debugging in browsers, Vite, and other build systems.

Breaking change

• Removed legacy v0.x encoding path (#849, 10a405b4). Legacy serializers, compatibility fuzz tests, and decoding shims are gone. All runtimes now rely on the v1.* encoding format. Documents created with v0.x must be migrated via an intermediate ≤1.8.x release before installing 1.9.0.

New features & improvements

• Spec-compliant JSONPath (#848, 21d13218). Ships a Pest-based parser, richer AST, the in/contains filter operators, better existence checks, and shared tests/benchmarks to keep Rust and WASM perfectly aligned.
• WASM debugging experience (#836, 6f987022; #844, 53f55331). Adds loro-wasm-tools for embedding sourcemaps, automates sourcemap publishing in CI, and hosts the maps in a dedicated workspace package so source-level debugging works without manual steps.
• Better bundler support (#852 3af6a857, #851 366f0161). Patches the JS entry points so esbuild and rsbuild can import the WASM bundle with zero loader overrides.
• Bun runtime improvements (#829 b8c070fd, #828 cf123453, #827 8b622619, #834 865bccba). Streams the WASM binary during bundling, pre-seeds the externref table, integrates Bun into CI, and removes earlier hacks that hid loader bugs.
• JavaScript performance (#820 c2c535c1). Event conversion now runs exactly once per callback invocation, trimming overhead during heavy real-time editing sessions.
• Core dependency refresh (e8f79de8, b2f5e107). Upgrades generic-btree and the columnar storage crate to pick up the latest bug fixes and perf wins.

Bug fixes & stability

• Fixed tree undo operations that moved nodes between siblings (#821 76a8728e).
• Resolved container ID bookkeeping when exporting shallow snapshots (#823 b72a759a) and ensured pending containers now return None instead of leaking state (#840 35d9064d).
• Prevented LoroMap entries from turning into null after applyDiff (#825 3afc4d52).
• Ensured undo manager callbacks fire without tripping Rust aliasing violations (#831 a39daf85).
• Guarded against panics when cursors point to deleted entries (#835 e97e6056) and when fetching unknown cursors in JS integration tests.
• Cleaned up WASM loader glue so we no longer rely on an extra patch (#834 865bccba) and added multiple Bun regression tests (#828 cf123453).
• Tightened CI release scripts (74b78514, 2383cdc1, 4740a04c, 3373e046, 24f93249) to keep loro-wasm artifacts and sourcemaps publishing in sync.

In the JavaScript package loro-crdt@1.8.0, we changed event emission from “after a microtask” to synchronous dispatch. This makes event handling simpler and less error‑prone.

Why we changed it

Historically, the JS binding emitted events after a microtask. The reason was to avoid Rust borrow/aliasing issues: if an event triggered inside doc.commit() re‑entered the same doc, Rust could panic because commit() holds a borrow and reusing the object would violate borrowing rules. Deferring events to a microtask avoided that re‑entrancy. (Background: Loro’s JS API exposes subscriptions via doc.subscribe(...); the docs note that events used to arrive after a microtask. ([Loro][1]))

However, this deferral made app logic fragile. There was a window between the mutation and the event callback. Example: the app receives the event from CRDT “delete the 3rd character of Hi!”, but during the microtask gap the app state changed Hi! → Hi. When the deferred event arrives, applying a “delete index 2” delta can be wrong. In practice, users had to maintain an awkward invariant: don’t mutate the app state during that microtask if you consume delta updates.

What’s new in 1.8.0

Events are now dispatched synchronously—that is, your listeners run before the top‑level JS call (e.g., doc.commit()) returns. To keep this safe with Rust’s borrowing:

• We keep a global queue of “pending (listener, event)” pairs.
• JS wrappers decorate APIs that can borrow the Rust doc (e.g., commit, import/export, checkout).
• The wrapper calls into WASM/Rust, returns from the borrow, then flushes the queue and clears it.
• Because callbacks run outside the borrowed region, listeners can freely call doc APIs without triggering borrow violations.

What this means for your app

• Simpler state updates. No more microtask gap; event ordering matches your mutation order.
• Fewer footguns with deltas. You no longer need to uphold “don’t touch the doc during the microtask” when applying delta‑style updates.
• Listeners can still safely use doc.

This is implemented by skipping the scan when importing a snapshot, which avoids running the decompression during the import process (but we need to ensure the parent-child link is still accessible in Arena). It also skips the checksum check in the import_all method on MemKV because we already check the checksum in the header of the snapshot/update.

v1.0.0 vs v1.6.0

You can find the benchmark here.

Now you can directly browse the current state and complete edit history of your Loro documents in the browser. You can also use this tool to time travel to any version in the history of your Loro document.

1. New Hooks

doc.subscribePreCommit(listener) - Modify commit options before processing:

This hook is particularly useful because doc.commit() is often invoked implicitly in various methods such as doc.import, doc.export, doc.checkout, and doc.exportJsonUpdates. Without this hook, users attempting to add custom messages to each commit might miss these implicit commit triggers.

const doc = new LoroDoc();
doc.setPeerId(0);
doc.subscribePreCommit((e) => {
  e.modifier.setMessage("test").setTimestamp(Date.now());
});
doc.getList("list").insert(0, 100);
doc.commit();
expect(doc.getChangeAt({ peer: "0", counter: 0 }).message).toBe("test");

Advanced Example - Creating a Merkle DAG:

const doc = new LoroDoc();
doc.setPeerId(0);
doc.subscribePreCommit((e) => {
  const changes = doc.exportJsonInIdSpan(e.changeMeta);
  expect(changes).toHaveLength(1);
  const hash = crypto.createHash("sha256");
  const change = {
    ...changes[0],
    deps: changes[0].deps.map((d) => {
      const depChange = doc.getChangeAt(idStrToId(d));
      return depChange.message;
    }),
  };
  hash.update(JSON.stringify(change));
  const sha256Hash = hash.digest("hex");
  e.modifier.setMessage(sha256Hash);
});

doc.getList("list").insert(0, 100);
doc.commit();

expect(doc.getChangeAt({ peer: "0", counter: 0 }).message).toBe(
  "2af99cf93869173984bcf6b1ce5412610b0413d027a5511a8f720a02a4432853",
);

doc.subscribeFirstCommitFromPeer(listener) - Triggers on first peer interaction:

This hook provides an ideal point to associate peer information (such as author identity) with the document.

const doc = new LoroDoc();
doc.setPeerId(0);
doc.subscribeFirstCommitFromPeer((e) => {
  doc.getMap("users").set(e.peer, "user-" + e.peer);
});
doc.getList("list").insert(0, 100);
doc.commit();
expect(doc.getMap("users").get("0")).toBe("user-0");

2. EphemeralStore

EphemeralStore is a better alternative to Awareness for ephemeral states:

Awareness is commonly used as a state-based CRDT for handling ephemeral states in real-time collaboration scenarios, such as cursor positions and application component highlights. As application complexity grows, Awareness may be set in multiple places, from cursor positions to user presence. However, the current version of Awareness doesn't support partial state updates, which means even minor mouse movements require synchronizing the entire Awareness state.

awareness.setLocalState({
  ...awareness.getLocalState(),
  x: 167,
});

Since Awareness is primarily used in real-time collaboration scenarios where consistency requirements are relatively low, we can make it more flexible. We've introduced EphemeralStore as an alternative to Awareness. Think of it as a simple key-value store that uses timestamp-based last-write-wins for conflict resolution. You can choose the appropriate granularity for your key-value pairs based on your application's needs, and only modified key-value pairs are synchronized.

    EphemeralStore,
    EphemeralListener,
    EphemeralStoreEvent,
} from "loro-crdt";

const store = new EphemeralStore();
// Set ephemeral data
store.set("user-alice", {
    anchor: 10,
    focus: 20,
    user: "Alice"
});

// Encode only the data for `loro-prosemirror`
const encoded = store.encode("user-alice")
const newStore = new EphemeralStore();
newStore.subscribe((e: EphemeralStoreEvent) => {
    // Listen to changes from `local`, `remote`, or `timeout` events
});

newStore.apply(encoded);
console.log(newStore.get("user-alice"))
// {
//     anchor: 10,
//     focus: 20,
//     user: "Alice"
// }

Fix

• Fixed text styling at end "\n" character
• Added JSON support for current transaction operations
• For environments that support multi-threading such as Rust and Swift, LoroDoc can now be directly and safely shared and accessed in parallel across multiple threads without triggering the previous WouldBlock panic.

• You can get the version of Loro by LORO_VERSION
• setNextCommitOrigin(origin: string): Set the origin of the next commit.
• setNextCommitTimestamp(timestamp: number): Set the timestamp of the next commit.
• setNextCommitOptions(options: CommitOption): Set the options of the next commit.
• clearNextCommitOptions(): Clear the options of the next commit.
• configDefaultTextStyle(style: TextStyle): Configures the default text style for the document.
• getUncommittedOpsAsJson(): Get the pending operations from the current transaction in JSON format

Fix

• fix: memory leak issue #647
• fix: mark err on detached LoroText #659
• fix: detached loro text issues #665
• fix: entity index when the tree is empty #670

• add unsubscribe() for Subscription.

Fix

• fix: getting values by path in LoroTree #643
• fix: should be able to call subscription after diffing [#637]
• fix: update long text may fail #633
• fix: map.keys() may return keys from deleted entries #618

• UndoManager's onPush now can access the change event.
• add getShallowValue for each container.

LoroDoc

• toJsonWithReplacer(replacer: (k, v)=>Value): Convert the document to a JSON value with a custom replacer function.
• revertTo(frontiers: Frontiers): Revert the document to the given frontiers.
• findIdSpansBetween(from: Frontiers, to: Frontiers): Find the op id spans that between the from version and the to version.
• exportJsonInIdSpan(idSpan: IdSpan): Export the readable [Change]s in the given [IdSpan].

Fix

• fix: prevent merging remote changes based on local changeMergeInterval config #643
• fix: should commit before travel_change_ancestors #599
• fix: panic when detach then attach #592
• fix: move child in current parent #589
• fix: panic when returned non-boolean value from text.iter(f) #578

• Add isDeleted() method to all container types (Text, Map, List, Tree, etc.)

LoroDoc

• changeCount(): Get the number of changes in the oplog.
• opCount(): Get the number of ops in the oplog.

VersionVector

• setEnd(id: ID): Set the exclusive ending point. target id will NOT be included by self.
• setLast(id: ID): Set the inclusive ending point. target id will be included.
• remove(peer: PeerID): Remove the specific peer id.
• length(): Get the number of peers in the VersionVector.

Change

• Return ImportStatus in the importUpdateBatch method.
• Fractional index is enabled by default now.

Fix

• fix: getOrCreateContainer should not throw if value is null #576
• fix: dead loop when importing updates #570

LoroDoc

• forkAt(frontiers: Frontiers): Fork the document at the given frontiers.
• getChangedContainersIn(id: ID, len: number): Gets container IDs modified in the given ID range.
• ``

LoroText

• getEditorOf(pos: number): Get the editor of the text at the given position.
• push(s: string): Push a string to the end of the text.

LoroMap

• getLastEditor(key: string): Get the peer id of the last editor on the given entry

LoroList

• getIdAt(pos: number): Get the ID of the list item at the given position.
• pushContainer(child: Container): Push a container to the end of the list.

LoroMovableList

• getCreatorAt(pos: number): Get the creator of the list item at the given position.
• getLastMoverAt(pos: number): Get the last mover of the list item at the given position.
• getLastEditorAt(pos: number): Get the last editor of the list item at the given position.
• pushContainer(child: Container): Push a container to the end of the list.

LoroTree

• toJSON(): Get JSON format of the LoroTreeNode.

Fix

• fix get correct encode blob info #545
• fix: avoid creating non-root containers that doesn't exist by get_container api #541
• fix: define the fork behavior when the doc is detached #537

It has a stable encoding format, faster document import and export speed, better version control capabilities, and a shallow snapshot. For more information, please check the blog.

The following are the specific API changes:

New

LoroDoc

• getChange(id: ID): get ChangeMeta by ID.
• setDetachedEditing(flag: boolean): Enables editing in detached mode, which is disabled by default.
• isDetachedEditingEnabled(): Whether the editing is enabled in detached mode.
• setNextCommitMessage(msg: string): Set the commit message of the next commit.
• shallowSinceVV(): The doc only contains the history since this version.
• shallowSinceFrontiers(): The doc only contains the history since this version.
• export(mode: ExportMode): Export the document based on the specified ExportMode. see more details here.
• getDeepValueWithID(): Get deep value of the document with container id.
• subscribeLocalUpdates(callback:(bytes: Uint8Array) => void): Subscribe to updates from local edits.
• getPathToContainer(id: ContainerID): Get the path from the root to the container.
• JSONPath(jsonPath: string): Evaluate JSONPath against a LoroDoc.
• forkAt(frontiers: Frontiers): LoroDoc: Creates a new LoroDoc at a specified version (Frontiers)
• getPendingTxnLength():number: Get the number of operations in the pending transaction.
• travelChangeAncestors(ids: ID[], callback: (meta: ChangeMeta)->bool): Iterate over all changes including the input id in order, and stop iterating if the callback returns false.

LoroText

• updateByLine(text: string): Update the current text based on the provided text line by line like git.

LoroList

• toArray(): ValueOrContainer[]: Get elements of the list. If the value is a child container, the corresponding Container will be returned.
• clear(): Delete all elements in the list.

LoroMovableList

• toArray(): ValueOrContainer[]: Get elements of the list. If the value is a child container, the corresponding Container will be returned.
• clear(): Delete all elements in the list.

LoroMap

• clear(): Delete all key-value pairs in the map.

LoroTree

• enableFractionalIndex(jitter: number): Set whether to generate fractional index for Tree Position.
• disableFractionalIndex(): Disable the fractional index generation for Tree Position when you don't need the Tree's siblings to be sorted. The fractional index will be always default.
• isFractionalIndexEnabled(): Whether the tree enables the fractional index generation.
• isNodeDeleted(id: TreeID): Return undefined if the node is not exist, otherwise return true if the node is deleted.
• getNodes(prop: getNodesProp): LoroTreeNode[]: Get the flat array of the forest. If with_deleted is true, the deleted nodes will be included.

UndoManager

• clear(): Clear the Undo and Redo stack of UndoManager

Changes

LoroDoc

• Move setFractionalIndexJitter() to LoroTree, you can set whether to enable or disable it for each Tree Container.
• import(), importWith() and importJsonUpdates will return ImportStatus for indicating which ops have been successfully applied and which ops are pending.
• New Subscription for event.
• In Loro 1.0, doc.version() doc.frontiers() doc.oplogVersion() and doc.oplogFrontiers() even if ops has not been committed, it indicates the latest version of all operations.
• rename Loro to LoroDoc.

LoroTree

• contains(id: TreeID): Return true even if the node exists in the internal state and has been deleted.
• nodes(): deleted nodes will be included now, you can use isDeleted() to filter.
• toJSON(): Now use the hierarchical approach to express the tree structure.

Deprecation

LoroDoc

• exportFrom(version) and exportSnapshot() are deprecated, use export(mode: ExportMode) instead.