loro-crdt 1.16.3 → 1.16.4

package/bundler/loro_wasm.d.ts

@@ -322,6 +322,29 @@ interface LoroDoc {
     diff(from: OpId[], to: OpId[], for_json?: boolean): [ContainerID, JsonDiff|Diff][];
 }
 
+/**
+ * Options for `LoroDoc.applyDiff`.
+ */
+export interface ApplyDiffOptions {
+    /**
+     * Read the batch as the result of `doc.diff()`: a mergeable child that the batch makes
+     * visible again carries its full content, which is aligned with whatever hidden state the
+     * target document keeps for it (none, the same, or different).
+     *
+     * Only use it for `doc.diff()` results (also after a JSON round trip), or for events from
+     * `import`/`checkout`, which report a revived child with its full content.
+     *
+     * Never use it for events from local commits. A local re-activation (such as
+     * `ensureMergeableCounter` over a deleted key) reports only the parent map change plus the
+     * commit's own ops, because the child's content did not change. With `fullState`, a
+     * missing child entry means "empty" and an entry means the whole content, so the hidden
+     * child would be cleared or overwritten (e.g. a counter at 7 becomes 0). Leave it unset
+     * (the default) for such events: their entries are increments, which is right when the
+     * target shares the source's hidden state.
+     */
+    fullState?: boolean;
+}
+
 /**
  * Represents a `Delta` type which is a union of different operations that can be performed.
  *
@@ -1949,8 +1972,25 @@ export class LoroDoc {
    * doc2.applyDiff(diff);
    * console.log(doc2.getText("text").toString()); // "Hello"
    * ```
+   *
+   * Pass `{ fullState: true }` when applying the result of `doc.diff()` to a document that may
+   * keep hidden state for a mergeable child the diff makes visible again (e.g. applying
+   * `doc.diff(afterDelete, beforeDelete)` to `doc` itself or to a copy of it). The child's
+   * entry is then read as its full content and aligned with that hidden state. Without it
+   * (the default), entries are applied as increments, which is right for events forwarded to
+   * a document that shares the source's hidden state. Never pass it for events from local
+   * commits; see `ApplyDiffOptions.fullState`.
+   *
+   * ```ts
+   * const text = doc.getMap("m").ensureMergeableText("t");
+   * text.insert(0, "hello");
+   * const before = doc.frontiers();
+   * doc.getMap("m").delete("t");
+   * doc.applyDiff(doc.diff(doc.frontiers(), before), { fullState: true });
+   * console.log(doc.getMap("m").get("t").toString()); // "hello"
+   * ```
    */
-  applyDiff(diff: [ContainerID, Diff|JsonDiff][]): void;
+  applyDiff(diff: [ContainerID, Diff|JsonDiff][], options?: ApplyDiffOptions | null): void;
   /**
    * Check if the doc contains the full history.
    */
@@ -3979,10 +4019,19 @@ export class UndoManager {
   peer(): PeerID;
   /**
    * Redo the last undone operation.
+   *
+   * Throws like `undo` on steps that would recreate a container of an
+   * unknown type.
    */
   redo(): boolean;
   /**
    * Undo the last operation.
+   *
+   * Throws without changing the doc if the step would have to recreate a
+   * container of a type unknown to this version (created by a newer
+   * loro-crdt). That step, with every edit merged into it, is dropped and its
+   * edits stay; the next call undoes the step before it, rebased over the
+   * dropped step's edits like over a remote peer's.
    */
   undo(): boolean;
   clear(): void;

package/bundler/loro_wasm_bg.js

@@ -1,4 +1,4 @@
-import { stateBinary, stateCid, stateContainer, stateIndex, stateOptions, stateRootCid, stateSet, stateSlice, stateValue } from './snippets/loro-wasm-c600d14705866f8f/inline0.js';
+import { stateBinary, stateCid, stateContainer, stateIndex, stateOptions, stateRootCid, stateSet, stateSlice, stateValue } from './snippets/loro-wasm-704a44faa43c032c/inline0.js';
 
 let wasm;
 export function __wbg_set_wasm(val) {
@@ -1360,12 +1360,30 @@ export class LoroDoc {
      * doc2.applyDiff(diff);
      * console.log(doc2.getText("text").toString()); // "Hello"
      * ```
+     *
+     * Pass `{ fullState: true }` when applying the result of `doc.diff()` to a document that may
+     * keep hidden state for a mergeable child the diff makes visible again (e.g. applying
+     * `doc.diff(afterDelete, beforeDelete)` to `doc` itself or to a copy of it). The child's
+     * entry is then read as its full content and aligned with that hidden state. Without it
+     * (the default), entries are applied as increments, which is right for events forwarded to
+     * a document that shares the source's hidden state. Never pass it for events from local
+     * commits; see `ApplyDiffOptions.fullState`.
+     *
+     * ```ts
+     * const text = doc.getMap("m").ensureMergeableText("t");
+     * text.insert(0, "hello");
+     * const before = doc.frontiers();
+     * doc.getMap("m").delete("t");
+     * doc.applyDiff(doc.diff(doc.frontiers(), before), { fullState: true });
+     * console.log(doc.getMap("m").get("t").toString()); // "hello"
+     * ```
      * @param {[ContainerID, Diff|JsonDiff][]} diff
+     * @param {ApplyDiffOptions | null} [options]
      */
-    applyDiff(diff) {
+    applyDiff(diff, options) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.lorodoc_applyDiff(retptr, this.__wbg_ptr, addHeapObject(diff));
+            wasm.lorodoc_applyDiff(retptr, this.__wbg_ptr, addHeapObject(diff), isLikeNone(options) ? 0 : addHeapObject(options));
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
             if (r1) {
@@ -7421,6 +7439,9 @@ export class UndoManager {
     }
     /**
      * Redo the last undone operation.
+     *
+     * Throws like `undo` on steps that would recreate a container of an
+     * unknown type.
      * @returns {boolean}
      */
     redo() {
@@ -7440,6 +7461,12 @@ export class UndoManager {
     }
     /**
      * Undo the last operation.
+     *
+     * Throws without changing the doc if the step would have to recreate a
+     * container of a type unknown to this version (created by a newer
+     * loro-crdt). That step, with every edit merged into it, is dropped and its
+     * edits stay; the next call undoes the step before it, rebased over the
+     * dropped step's edits like over a remote peer's.
      * @returns {boolean}
      */
     undo() {
@@ -7828,7 +7855,7 @@ export function __wbg_entries_c8a90a7ed73e84ce(arg0) {
     return addHeapObject(ret);
 };
 
-export function __wbg_error_10d6926de361eb2b(arg0, arg1) {
+export function __wbg_error_1d6f2b3f2c5a33ec(arg0, arg1) {
     console.error(getStringFromWasm0(arg0, arg1));
 };
 
@@ -7959,7 +7986,7 @@ export function __wbg_log_cb9e190acc5753fb(arg0, arg1) {
     }
 };
 
-export function __wbg_log_d5951556f2f10ec9(arg0, arg1) {
+export function __wbg_log_f665cabe523a97df(arg0, arg1) {
     console.log(getStringFromWasm0(arg0, arg1));
 };
 
@@ -8144,45 +8171,45 @@ export function __wbg_setindex_dcd71eabf405bde1(arg0, arg1, arg2) {
     getObject(arg0)[arg1 >>> 0] = arg2;
 };
 
-export function __wbg_stateBinary_64e9eb9b37720ab6(arg0, arg1) {
+export function __wbg_stateBinary_9e1da8a4daa74bc6(arg0, arg1) {
     const ret = stateBinary(getArrayU8FromWasm0(arg0, arg1));
     return addHeapObject(ret);
 };
 
-export function __wbg_stateCid_760e963fd4c95f01(arg0, arg1, arg2) {
+export function __wbg_stateCid_c43ea762fb462319(arg0, arg1, arg2) {
     const ret = stateCid(getObject(arg0), arg1, arg2);
     return addHeapObject(ret);
 };
 
-export function __wbg_stateContainer_71de82dd2efd60eb(arg0, arg1, arg2) {
+export function __wbg_stateContainer_cd983f42c6fe987d(arg0, arg1, arg2) {
     const ret = stateContainer(arg0, getObject(arg1), takeObject(arg2));
     return addHeapObject(ret);
 };
 
-export function __wbg_stateIndex_acd88b869f874497() { return handleError(function (arg0, arg1, arg2) {
+export function __wbg_stateIndex_1fbac6394e58cff9() { return handleError(function (arg0, arg1, arg2) {
     stateIndex(getObject(arg0), arg1 >>> 0, getObject(arg2));
 }, arguments) };
 
-export function __wbg_stateOptions_8486fef4478d16b3() { return handleError(function (arg0, arg1) {
+export function __wbg_stateOptions_dcb483514d1b925d() { return handleError(function (arg0, arg1) {
     const ret = stateOptions(takeObject(arg0), arg1 !== 0);
     return addHeapObject(ret);
 }, arguments) };
 
-export function __wbg_stateRootCid_964d9fbc9bfbcea3(arg0, arg1, arg2) {
+export function __wbg_stateRootCid_9198769cdd9f37d5(arg0, arg1, arg2) {
     const ret = stateRootCid(getStringFromWasm0(arg0, arg1), arg2);
     return addHeapObject(ret);
 };
 
-export function __wbg_stateSet_6cd1dd82536a3182() { return handleError(function (arg0, arg1, arg2) {
+export function __wbg_stateSet_a3e74b27d3d26f9d() { return handleError(function (arg0, arg1, arg2) {
     stateSet(getObject(arg0), getObject(arg1), getObject(arg2));
 }, arguments) };
 
-export function __wbg_stateSlice_8d4107ebb0dfc484(arg0, arg1, arg2) {
+export function __wbg_stateSlice_aafffe8ecba122b8(arg0, arg1, arg2) {
     const ret = stateSlice(takeObject(arg0), arg1 >>> 0, arg2 >>> 0);
     return addHeapObject(ret);
 };
 
-export function __wbg_stateValue_0727099e81830513(arg0) {
+export function __wbg_stateValue_8ed644fcdb61558c(arg0) {
     const ret = stateValue(takeObject(arg0));
     return addHeapObject(ret);
 };
@@ -8232,7 +8259,7 @@ export function __wbg_versionvector_new(arg0) {
     return addHeapObject(ret);
 };
 
-export function __wbg_warn_576423aac512a858(arg0, arg1) {
+export function __wbg_warn_52b319b1b6be3d2f(arg0, arg1) {
     console.warn(getStringFromWasm0(arg0, arg1));
 };
 
@@ -8274,12 +8301,12 @@ export function __wbindgen_cb_drop(arg0) {
     return ret;
 };
 
-export function __wbindgen_closure_wrapper283(arg0, arg1, arg2) {
+export function __wbindgen_closure_wrapper285(arg0, arg1, arg2) {
     const ret = makeMutClosure(arg0, arg1, 15, __wbg_adapter_58);
     return addHeapObject(ret);
 };
 
-export function __wbindgen_closure_wrapper542(arg0, arg1, arg2) {
+export function __wbindgen_closure_wrapper544(arg0, arg1, arg2) {
     const ret = makeMutClosure(arg0, arg1, 15, __wbg_adapter_61);
     return addHeapObject(ret);
 };

package/bundler/loro_wasm_bg.wasm.d.ts

@@ -66,7 +66,7 @@ export const lorocounter_parent: (a: number, b: number) => void;
 export const lorocounter_subscribe: (a: number, b: number, c: number) => void;
 export const lorocounter_toContainerTree: (a: number, b: number, c: number) => void;
 export const lorodoc_JSONPath: (a: number, b: number, c: number, d: number) => void;
-export const lorodoc_applyDiff: (a: number, b: number, c: number) => void;
+export const lorodoc_applyDiff: (a: number, b: number, c: number, d: number) => void;
 export const lorodoc_attach: (a: number) => void;
 export const lorodoc_changeCount: (a: number) => number;
 export const lorodoc_checkout: (a: number, b: number, c: number, d: number) => void;

package/nodejs/loro_wasm.d.ts

@@ -322,6 +322,29 @@ interface LoroDoc {
     diff(from: OpId[], to: OpId[], for_json?: boolean): [ContainerID, JsonDiff|Diff][];
 }
 
+/**
+ * Options for `LoroDoc.applyDiff`.
+ */
+export interface ApplyDiffOptions {
+    /**
+     * Read the batch as the result of `doc.diff()`: a mergeable child that the batch makes
+     * visible again carries its full content, which is aligned with whatever hidden state the
+     * target document keeps for it (none, the same, or different).
+     *
+     * Only use it for `doc.diff()` results (also after a JSON round trip), or for events from
+     * `import`/`checkout`, which report a revived child with its full content.
+     *
+     * Never use it for events from local commits. A local re-activation (such as
+     * `ensureMergeableCounter` over a deleted key) reports only the parent map change plus the
+     * commit's own ops, because the child's content did not change. With `fullState`, a
+     * missing child entry means "empty" and an entry means the whole content, so the hidden
+     * child would be cleared or overwritten (e.g. a counter at 7 becomes 0). Leave it unset
+     * (the default) for such events: their entries are increments, which is right when the
+     * target shares the source's hidden state.
+     */
+    fullState?: boolean;
+}
+
 /**
  * Represents a `Delta` type which is a union of different operations that can be performed.
  *
@@ -1949,8 +1972,25 @@ export class LoroDoc {
    * doc2.applyDiff(diff);
    * console.log(doc2.getText("text").toString()); // "Hello"
    * ```
+   *
+   * Pass `{ fullState: true }` when applying the result of `doc.diff()` to a document that may
+   * keep hidden state for a mergeable child the diff makes visible again (e.g. applying
+   * `doc.diff(afterDelete, beforeDelete)` to `doc` itself or to a copy of it). The child's
+   * entry is then read as its full content and aligned with that hidden state. Without it
+   * (the default), entries are applied as increments, which is right for events forwarded to
+   * a document that shares the source's hidden state. Never pass it for events from local
+   * commits; see `ApplyDiffOptions.fullState`.
+   *
+   * ```ts
+   * const text = doc.getMap("m").ensureMergeableText("t");
+   * text.insert(0, "hello");
+   * const before = doc.frontiers();
+   * doc.getMap("m").delete("t");
+   * doc.applyDiff(doc.diff(doc.frontiers(), before), { fullState: true });
+   * console.log(doc.getMap("m").get("t").toString()); // "hello"
+   * ```
    */
-  applyDiff(diff: [ContainerID, Diff|JsonDiff][]): void;
+  applyDiff(diff: [ContainerID, Diff|JsonDiff][], options?: ApplyDiffOptions | null): void;
   /**
    * Check if the doc contains the full history.
    */
@@ -3979,10 +4019,19 @@ export class UndoManager {
   peer(): PeerID;
   /**
    * Redo the last undone operation.
+   *
+   * Throws like `undo` on steps that would recreate a container of an
+   * unknown type.
    */
   redo(): boolean;
   /**
    * Undo the last operation.
+   *
+   * Throws without changing the doc if the step would have to recreate a
+   * container of a type unknown to this version (created by a newer
+   * loro-crdt). That step, with every edit merged into it, is dropped and its
+   * edits stay; the next call undoes the step before it, rebased over the
+   * dropped step's edits like over a remote peer's.
    */
   undo(): boolean;
   clear(): void;

package/nodejs/loro_wasm.js

@@ -2,7 +2,7 @@
 let imports = {};
 imports['__wbindgen_placeholder__'] = module.exports;
 let wasm;
-const { stateBinary, stateCid, stateContainer, stateIndex, stateOptions, stateRootCid, stateSet, stateSlice, stateValue } = require(String.raw`./snippets/loro-wasm-c600d14705866f8f/inline0.js`);
+const { stateBinary, stateCid, stateContainer, stateIndex, stateOptions, stateRootCid, stateSet, stateSlice, stateValue } = require(String.raw`./snippets/loro-wasm-704a44faa43c032c/inline0.js`);
 const { TextEncoder, TextDecoder } = require(`util`);
 
 const heap = new Array(128).fill(undefined);
@@ -1360,12 +1360,30 @@ class LoroDoc {
      * doc2.applyDiff(diff);
      * console.log(doc2.getText("text").toString()); // "Hello"
      * ```
+     *
+     * Pass `{ fullState: true }` when applying the result of `doc.diff()` to a document that may
+     * keep hidden state for a mergeable child the diff makes visible again (e.g. applying
+     * `doc.diff(afterDelete, beforeDelete)` to `doc` itself or to a copy of it). The child's
+     * entry is then read as its full content and aligned with that hidden state. Without it
+     * (the default), entries are applied as increments, which is right for events forwarded to
+     * a document that shares the source's hidden state. Never pass it for events from local
+     * commits; see `ApplyDiffOptions.fullState`.
+     *
+     * ```ts
+     * const text = doc.getMap("m").ensureMergeableText("t");
+     * text.insert(0, "hello");
+     * const before = doc.frontiers();
+     * doc.getMap("m").delete("t");
+     * doc.applyDiff(doc.diff(doc.frontiers(), before), { fullState: true });
+     * console.log(doc.getMap("m").get("t").toString()); // "hello"
+     * ```
      * @param {[ContainerID, Diff|JsonDiff][]} diff
+     * @param {ApplyDiffOptions | null} [options]
      */
-    applyDiff(diff) {
+    applyDiff(diff, options) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.lorodoc_applyDiff(retptr, this.__wbg_ptr, addHeapObject(diff));
+            wasm.lorodoc_applyDiff(retptr, this.__wbg_ptr, addHeapObject(diff), isLikeNone(options) ? 0 : addHeapObject(options));
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
             if (r1) {
@@ -7428,6 +7446,9 @@ class UndoManager {
     }
     /**
      * Redo the last undone operation.
+     *
+     * Throws like `undo` on steps that would recreate a container of an
+     * unknown type.
      * @returns {boolean}
      */
     redo() {
@@ -7447,6 +7468,12 @@ class UndoManager {
     }
     /**
      * Undo the last operation.
+     *
+     * Throws without changing the doc if the step would have to recreate a
+     * container of a type unknown to this version (created by a newer
+     * loro-crdt). That step, with every edit merged into it, is dropped and its
+     * edits stay; the next call undoes the step before it, rebased over the
+     * dropped step's edits like over a remote peer's.
      * @returns {boolean}
      */
     undo() {
@@ -7837,7 +7864,7 @@ module.exports.__wbg_entries_c8a90a7ed73e84ce = function(arg0) {
     return addHeapObject(ret);
 };
 
-module.exports.__wbg_error_10d6926de361eb2b = function(arg0, arg1) {
+module.exports.__wbg_error_1d6f2b3f2c5a33ec = function(arg0, arg1) {
     console.error(getStringFromWasm0(arg0, arg1));
 };
 
@@ -7968,7 +7995,7 @@ module.exports.__wbg_log_cb9e190acc5753fb = function(arg0, arg1) {
     }
 };
 
-module.exports.__wbg_log_d5951556f2f10ec9 = function(arg0, arg1) {
+module.exports.__wbg_log_f665cabe523a97df = function(arg0, arg1) {
     console.log(getStringFromWasm0(arg0, arg1));
 };
 
@@ -8153,45 +8180,45 @@ module.exports.__wbg_setindex_dcd71eabf405bde1 = function(arg0, arg1, arg2) {
     getObject(arg0)[arg1 >>> 0] = arg2;
 };
 
-module.exports.__wbg_stateBinary_64e9eb9b37720ab6 = function(arg0, arg1) {
+module.exports.__wbg_stateBinary_9e1da8a4daa74bc6 = function(arg0, arg1) {
     const ret = stateBinary(getArrayU8FromWasm0(arg0, arg1));
     return addHeapObject(ret);
 };
 
-module.exports.__wbg_stateCid_760e963fd4c95f01 = function(arg0, arg1, arg2) {
+module.exports.__wbg_stateCid_c43ea762fb462319 = function(arg0, arg1, arg2) {
     const ret = stateCid(getObject(arg0), arg1, arg2);
     return addHeapObject(ret);
 };
 
-module.exports.__wbg_stateContainer_71de82dd2efd60eb = function(arg0, arg1, arg2) {
+module.exports.__wbg_stateContainer_cd983f42c6fe987d = function(arg0, arg1, arg2) {
     const ret = stateContainer(arg0, getObject(arg1), takeObject(arg2));
     return addHeapObject(ret);
 };
 
-module.exports.__wbg_stateIndex_acd88b869f874497 = function() { return handleError(function (arg0, arg1, arg2) {
+module.exports.__wbg_stateIndex_1fbac6394e58cff9 = function() { return handleError(function (arg0, arg1, arg2) {
     stateIndex(getObject(arg0), arg1 >>> 0, getObject(arg2));
 }, arguments) };
 
-module.exports.__wbg_stateOptions_8486fef4478d16b3 = function() { return handleError(function (arg0, arg1) {
+module.exports.__wbg_stateOptions_dcb483514d1b925d = function() { return handleError(function (arg0, arg1) {
     const ret = stateOptions(takeObject(arg0), arg1 !== 0);
     return addHeapObject(ret);
 }, arguments) };
 
-module.exports.__wbg_stateRootCid_964d9fbc9bfbcea3 = function(arg0, arg1, arg2) {
+module.exports.__wbg_stateRootCid_9198769cdd9f37d5 = function(arg0, arg1, arg2) {
     const ret = stateRootCid(getStringFromWasm0(arg0, arg1), arg2);
     return addHeapObject(ret);
 };
 
-module.exports.__wbg_stateSet_6cd1dd82536a3182 = function() { return handleError(function (arg0, arg1, arg2) {
+module.exports.__wbg_stateSet_a3e74b27d3d26f9d = function() { return handleError(function (arg0, arg1, arg2) {
     stateSet(getObject(arg0), getObject(arg1), getObject(arg2));
 }, arguments) };
 
-module.exports.__wbg_stateSlice_8d4107ebb0dfc484 = function(arg0, arg1, arg2) {
+module.exports.__wbg_stateSlice_aafffe8ecba122b8 = function(arg0, arg1, arg2) {
     const ret = stateSlice(takeObject(arg0), arg1 >>> 0, arg2 >>> 0);
     return addHeapObject(ret);
 };
 
-module.exports.__wbg_stateValue_0727099e81830513 = function(arg0) {
+module.exports.__wbg_stateValue_8ed644fcdb61558c = function(arg0) {
     const ret = stateValue(takeObject(arg0));
     return addHeapObject(ret);
 };
@@ -8241,7 +8268,7 @@ module.exports.__wbg_versionvector_new = function(arg0) {
     return addHeapObject(ret);
 };
 
-module.exports.__wbg_warn_576423aac512a858 = function(arg0, arg1) {
+module.exports.__wbg_warn_52b319b1b6be3d2f = function(arg0, arg1) {
     console.warn(getStringFromWasm0(arg0, arg1));
 };
 
@@ -8283,12 +8310,12 @@ module.exports.__wbindgen_cb_drop = function(arg0) {
     return ret;
 };
 
-module.exports.__wbindgen_closure_wrapper283 = function(arg0, arg1, arg2) {
+module.exports.__wbindgen_closure_wrapper285 = function(arg0, arg1, arg2) {
     const ret = makeMutClosure(arg0, arg1, 15, __wbg_adapter_58);
     return addHeapObject(ret);
 };
 
-module.exports.__wbindgen_closure_wrapper542 = function(arg0, arg1, arg2) {
+module.exports.__wbindgen_closure_wrapper544 = function(arg0, arg1, arg2) {
     const ret = makeMutClosure(arg0, arg1, 15, __wbg_adapter_61);
     return addHeapObject(ret);
 };

package/nodejs/loro_wasm_bg.wasm.d.ts

@@ -66,7 +66,7 @@ export const lorocounter_parent: (a: number, b: number) => void;
 export const lorocounter_subscribe: (a: number, b: number, c: number) => void;
 export const lorocounter_toContainerTree: (a: number, b: number, c: number) => void;
 export const lorodoc_JSONPath: (a: number, b: number, c: number, d: number) => void;
-export const lorodoc_applyDiff: (a: number, b: number, c: number) => void;
+export const lorodoc_applyDiff: (a: number, b: number, c: number, d: number) => void;
 export const lorodoc_attach: (a: number) => void;
 export const lorodoc_changeCount: (a: number) => number;
 export const lorodoc_checkout: (a: number, b: number, c: number, d: number) => void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "loro-crdt",
-  "version": "1.16.3",
+  "version": "1.16.4",
   "description": "Loro CRDTs is a high-performance CRDT framework that makes your app state synchronized, collaborative and maintainable effortlessly.",
   "keywords": [
     "crdt",

package/web/loro_wasm.d.ts

@@ -322,6 +322,29 @@ interface LoroDoc {
     diff(from: OpId[], to: OpId[], for_json?: boolean): [ContainerID, JsonDiff|Diff][];
 }
 
+/**
+ * Options for `LoroDoc.applyDiff`.
+ */
+export interface ApplyDiffOptions {
+    /**
+     * Read the batch as the result of `doc.diff()`: a mergeable child that the batch makes
+     * visible again carries its full content, which is aligned with whatever hidden state the
+     * target document keeps for it (none, the same, or different).
+     *
+     * Only use it for `doc.diff()` results (also after a JSON round trip), or for events from
+     * `import`/`checkout`, which report a revived child with its full content.
+     *
+     * Never use it for events from local commits. A local re-activation (such as
+     * `ensureMergeableCounter` over a deleted key) reports only the parent map change plus the
+     * commit's own ops, because the child's content did not change. With `fullState`, a
+     * missing child entry means "empty" and an entry means the whole content, so the hidden
+     * child would be cleared or overwritten (e.g. a counter at 7 becomes 0). Leave it unset
+     * (the default) for such events: their entries are increments, which is right when the
+     * target shares the source's hidden state.
+     */
+    fullState?: boolean;
+}
+
 /**
  * Represents a `Delta` type which is a union of different operations that can be performed.
  *
@@ -1949,8 +1972,25 @@ export class LoroDoc {
    * doc2.applyDiff(diff);
    * console.log(doc2.getText("text").toString()); // "Hello"
    * ```
+   *
+   * Pass `{ fullState: true }` when applying the result of `doc.diff()` to a document that may
+   * keep hidden state for a mergeable child the diff makes visible again (e.g. applying
+   * `doc.diff(afterDelete, beforeDelete)` to `doc` itself or to a copy of it). The child's
+   * entry is then read as its full content and aligned with that hidden state. Without it
+   * (the default), entries are applied as increments, which is right for events forwarded to
+   * a document that shares the source's hidden state. Never pass it for events from local
+   * commits; see `ApplyDiffOptions.fullState`.
+   *
+   * ```ts
+   * const text = doc.getMap("m").ensureMergeableText("t");
+   * text.insert(0, "hello");
+   * const before = doc.frontiers();
+   * doc.getMap("m").delete("t");
+   * doc.applyDiff(doc.diff(doc.frontiers(), before), { fullState: true });
+   * console.log(doc.getMap("m").get("t").toString()); // "hello"
+   * ```
    */
-  applyDiff(diff: [ContainerID, Diff|JsonDiff][]): void;
+  applyDiff(diff: [ContainerID, Diff|JsonDiff][], options?: ApplyDiffOptions | null): void;
   /**
    * Check if the doc contains the full history.
    */
@@ -3979,10 +4019,19 @@ export class UndoManager {
   peer(): PeerID;
   /**
    * Redo the last undone operation.
+   *
+   * Throws like `undo` on steps that would recreate a container of an
+   * unknown type.
    */
   redo(): boolean;
   /**
    * Undo the last operation.
+   *
+   * Throws without changing the doc if the step would have to recreate a
+   * container of a type unknown to this version (created by a newer
+   * loro-crdt). That step, with every edit merged into it, is dropped and its
+   * edits stay; the next call undoes the step before it, rebased over the
+   * dropped step's edits like over a remote peer's.
    */
   undo(): boolean;
   clear(): void;
@@ -4149,7 +4198,7 @@ export interface InitOutput {
   readonly lorocounter_subscribe: (a: number, b: number, c: number) => void;
   readonly lorocounter_toContainerTree: (a: number, b: number, c: number) => void;
   readonly lorodoc_JSONPath: (a: number, b: number, c: number, d: number) => void;
-  readonly lorodoc_applyDiff: (a: number, b: number, c: number) => void;
+  readonly lorodoc_applyDiff: (a: number, b: number, c: number, d: number) => void;
   readonly lorodoc_attach: (a: number) => void;
   readonly lorodoc_changeCount: (a: number) => number;
   readonly lorodoc_checkout: (a: number, b: number, c: number, d: number) => void;