loro-crdt 1.13.9 → 1.14.1

package/CHANGELOG.md

@@ -1,5 +1,74 @@
 # Changelog
 
+## 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
+
+- bbf21c3: fix: avoid unreadable WASM traps (`RuntimeError: unreachable executed`) on invalid arguments. `getCursor` with an invalid `side`, `getEditorOf` at an out-of-range position, and accessing an unknown container (created by a newer version of loro-crdt) now throw catchable JS errors with readable messages or return `undefined` instead of trapping the WASM instance.
+
+  feat: on a Rust panic, the full panic info (message, `file:line`, and the complete stack including the Rust call path) is now stored as a JS `Error` on `globalThis.__LORO_WASM_LAST_PANIC__` before the instance traps, so applications can recover readable diagnostics from a caught `RuntimeError`.
+
+  fix: the WASM start hook was never invoked in the `bundler`/`browser`/`base64` builds (the glue checked the JS namespace instead of the wasm exports for `__wbindgen_start`), so no panic hook was installed there at all. The start hook now runs in every build target.
+
+  feat: out-of-memory failures are now reported too. Allocation failure in WASM bypasses the panic hook and traps silently; the package now wraps the global allocator so OOM stores `loro-crdt: out of WASM memory: allocation of N bytes failed` on `globalThis.__LORO_WASM_LAST_PANIC__` and prints it to `console.error` before trapping.
+
+### Patch Changes
+
+- bbcaef6: Fix a panic on import that could permanently break a document's sync.
+
+  `import_changes_to_oplog` defers the changes whose deps are not yet in the DAG
+  and hands them to `extend_pending_changes_with_unknown_lamport` to be parked.
+  `try_apply_pending` runs in between and applies changes parked by earlier
+  imports, which advances the oplog version, so a deferred change can become
+  applicable — or already applied — by the time it is parked. Both outcomes used
+  to hit `unreachable!`, compiling to `RuntimeError: unreachable` in WASM.
+
+  The re-classification is now handled instead of asserted: a change that became
+  applicable is applied and cascaded into whatever it unblocks, an already-applied
+  one is skipped, and `ImportStatus` reports only what genuinely stayed pending.
+
+  This mattered most through `import_batch`, which force-detaches the document for
+  the duration of the batch and reattaches after the loop. The panic unwound past
+  the reattach and left the document detached, so every later import and export
+  failed and the document stopped syncing until the process restarted.
+
 ## 1.13.9
 
 ### Patch Changes