loro-crdt 1.14.0 → 1.15.0

package/CHANGELOG.md

@@ -1,5 +1,104 @@
 # Changelog
 
+## 1.15.0
+
+### Minor Changes
+
+- 5ea2e37: Add `pause()`, `resume()`, and `isPaused()` to `UndoManager`. While paused,
+  local edits are not recorded as undo steps and checkout events do not clear the
+  stacks. Import events (remote changes) are still processed so that the stacks
+  remain correctly transformed against concurrent edits. Use this to preserve
+  undo/redo history across temporary checkouts such as read-only history previews.
+
+### Patch Changes
+
+- 4d3d3f1: Shallow snapshot export no longer leaks the values of rich-text marks whose
+  whole range was deleted before the shallow root.
+
+  Deleting styled text removes the characters but keeps the style anchors, and the
+  shallow-root state encoding shipped each anchor's value verbatim — so a mark
+  value (e.g. an inline comment) that every read API already reported as gone
+  still appeared in the exported bytes, defeating the documented content-redaction
+  use of shallow snapshots. Dead style pairs now have their values nulled during
+  export (anchors stay, so positions and replay are unaffected). Styles that only
+  become dead after the shallow root keep their values so historical checkouts
+  render correctly, and styles configured with `expand: "both"` are kept because
+  an empty both-expand pair still applies to future inserts. Re-exporting a
+  shallow snapshot produced by an older version also cleans it.
+
+- 4837d07: Fix unbounded degradation when re-asserting identical text marks over styled ranges.
+
+  `mark` already tried to skip no-op marks, but the check used
+  `StyleRangeMap::get_styles_of_range`, which returns `None` whenever the marked
+  range spans more than one style-range leaf. On any document whose style ranges
+  are already fragmented (i.e. any document with styles), re-asserting an
+  identical mark recorded a new op every time.
+
+  Each redundant mark leaves a pair of style anchors in the container state
+  forever — they survive snapshots and are never consolidated — and every styled
+  read walks all of them. Callers that re-assert marks (for example editor
+  bindings syncing mark state) therefore permanently degraded styled reads without
+  bound: reading a 724-character paragraph went from ~5µs to ~4ms after 1000
+  redundant marks.
+
+  The skip path now falls back to `StyleRangeMap::range_has_key_value`, which
+  scans every style range covering the mark and reports whether each position
+  already resolves the key to the given value. Attached and detached texts both
+  use the new path when the single-leaf fast path cannot answer.
+
+- f4e011f: Fix an O(n^2) slowdown when reading styled text.
+
+  Building the per-range style metadata for `toDelta` / `getRichtextValue` (and
+  the sliced variants used to emit text events) deep-copied the whole `Styles`
+  map once per style range. Each key in that map owns the set of _every_ style op
+  covering the range, while the resulting `StyleMeta` keeps only the LWW winner,
+  so the copy scaled with the number of marks accumulated on the container and
+  then discarded all but one element of it — O(marks) per range across O(marks)
+  ranges. The conversion now borrows instead of cloning.
+
+  Style anchors are never consolidated, so marks accumulate in the container
+  state and every styled read paid for all of them. On a 724-character paragraph
+  carrying 2000 accumulated marks, a styled read drops from ~103ms to ~1ms; a
+  simulated editor binding that re-asserts marks on each keystroke drops from
+  ~5ms to ~200us per read after 500 keystrokes.
+
+## 1.14.1
+
+### Patch Changes
+
+- 76cc0f9: Make `importBatch` atomic and never leave the document detached.
+
+  `importBatch` force-detaches the document so each blob only touches the OpLog, then
+  reattaches with a single checkout at the end. Two exits skipped that reattach and
+  stranded the document in detached mode, where later imports stop being reflected in
+  the state, local edits branch off a stale version, and every later `attach()` re-runs
+  the same failing checkout:
+
+  - The closing checkout was `expect`ed to succeed. Remote ops that decode fine but are
+    rejected by state validation (for example a list insert past the end of the list)
+    only reach that validation here, because the blobs were imported while detached, so
+    a malformed blob turned into a panic — a `RuntimeError: unreachable` trap in WASM —
+    after the document had already been left detached.
+  - Any other panic while decoding or applying a blob unwound past the reattach.
+
+  The batch now runs inside an OpLog rollback scope. If the closing checkout cannot
+  apply the accumulated changes, the whole batch is rolled back and `importBatch`
+  returns the state-apply error with the document still attached and unchanged, instead
+  of trapping. A panic inside the batch reattaches before it is re-raised.
+
+  The pending-changes rollback journal now snapshots each touched slot as it was when
+  the scope began, instead of undoing individual mutations. The previous two-phase undo
+  resurrected changes that the same import both parked and unlocked — routine across a
+  batch — leaving pending entries that referenced container registrations the rollback
+  had already discarded, and pre-batch pending changes unlocked by a rolled-back batch
+  are now re-parked instead of silently dropped.
+
+  `importBatch` of out-of-order updates is also considerably faster: the import preflight
+  no longer rescans the whole pending set once per blob, which made such a batch
+  quadratic. Draining 12000 out-of-order updates in one `importBatch` goes from ~3.4s to
+  ~0.45s, with peak memory unchanged. In-order batches and single `import` calls are
+  unaffected.
+
 ## 1.14.0
 
 ### Minor Changes