loro-crdt 1.2.7 → 1.3.0

package/bundler/loro_wasm.d.ts

@@ -172,7 +172,7 @@ interface LoroDoc {
      * const doc = new LoroDoc();
      * const text = doc.getText("text");
      * text.insert(0, "Hello");
-     * text.mark(0, 2, {bold: true});
+     * text.mark({ start: 0, end: 2 }, "bold", true);
      * 
      * // Use delta to represent text
      * const json = doc.toJsonWithReplacer((key, value) => {
@@ -264,6 +264,27 @@ export type Value =
   | Value[]
   | undefined;
 
+export type IdSpan = {
+    peer: PeerID,
+    counter: number,
+    length: number,
+}
+
+export type VersionVectorDiff = {
+    /**
+     * The spans that the `from` side needs to retreat to reach the `to` side
+     *
+     * These spans are included in the `from`, but not in the `to`
+     */
+    retreat: IdSpan[],
+    /**
+     * The spans that the `from` side needs to forward to reach the `to` side
+     *
+     * These spans are included in the `to`, but not in the `from`
+     */
+    forward: IdSpan[],
+}
+
 export type UndoConfig = {
     mergeInterval?: number,
     maxUndoSteps?: number,
@@ -627,6 +648,8 @@ export interface LoroEventBatch {
      */
     currentTarget?: ContainerID;
     events: LoroEvent[];
+    from: Frontiers;
+    to: Frontiers;
 }
 
 /**
@@ -793,9 +816,19 @@ interface LoroDoc<T extends Record<string, Container> = Record<string, Container
      *
      * @param start - The start version vector.
      * @param end - The end version vector.
+     * @param withPeerCompression - Whether to compress the peer IDs in the updates. Defaults to true. If you want to process the operations in application code, set this to false.
      * @returns The updates in the given range.
      */
-    exportJsonUpdates(start?: VersionVector, end?: VersionVector): JsonSchema;
+    exportJsonUpdates(start?: VersionVector, end?: VersionVector, withPeerCompression?: boolean): JsonSchema;
+    /**
+     * Export the readable [`Change`]s in the given [`IdSpan`].
+     *
+     * The peers are not compressed in the returned changes.
+     *
+     * @param idSpan - The id span to export.
+     * @returns The changes in the given id span.
+     */
+    exportJsonInIdSpan(idSpan: IdSpan): JsonChange[];
 }
 interface LoroList<T = unknown> {
     new(): LoroList<T>;
@@ -1469,9 +1502,12 @@ export class LoroDoc {
 */
   setRecordTimestamp(auto_record: boolean): void;
 /**
-* If two continuous local changes are within the interval, they will be merged into one change.
+* If two continuous local changes are within (<=) the interval(**in seconds**), they will be merged into one change.
+*
+* The default value is 1_000 seconds.
 *
-* The default value is 1_000_000, the default unit is seconds.
+* By default, we record timestamps in seconds for each change. So if the merge interval is 1, and changes A and B
+* have timestamps of 3 and 4 respectively, then they will be merged into one change
 * @param {number} interval
 */
   setChangeMergeInterval(interval: number): void;
@@ -1653,6 +1689,54 @@ export class LoroDoc {
 */
   travelChangeAncestors(ids: ({ peer: PeerID, counter: number })[], f: (change: Change) => boolean): void;
 /**
+* Find the op id spans that between the `from` version and the `to` version.
+*
+* You can combine it with `exportJsonInIdSpan` to get the changes between two versions.
+*
+* You can use it to travel all the changes from `from` to `to`. `from` and `to` are frontiers,
+* and they can be concurrent to each other. You can use it to find all the changes related to an event:
+*
+* @example
+* ```ts
+* import { LoroDoc } from "loro-crdt";
+*
+* const docA = new LoroDoc();
+* docA.setPeerId("1");
+* const docB = new LoroDoc();
+*
+* docA.getText("text").update("Hello");
+* docA.commit();
+* const snapshot = docA.export({ mode: "snapshot" });
+* let done = false;
+* docB.subscribe(e => {
+*   const spans = docB.findIdSpansBetween(e.from, e.to);
+*   const changes = docB.exportJsonInIdSpan(spans.forward[0]);
+*   console.log(changes);
+*   // [{
+*   //   id: "0@1",
+*   //   timestamp: expect.any(Number),
+*   //   deps: [],
+*   //   lamport: 0,
+*   //   msg: undefined,
+*   //   ops: [{
+*   //     container: "cid:root-text:Text",
+*   //     counter: 0,
+*   //     content: {
+*   //       type: "insert",
+*   //       pos: 0,
+*   //       text: "Hello"
+*   //     }
+*   //   }]
+*   // }]
+* });
+* docB.import(snapshot);
+* ```
+* @param {({ peer: PeerID, counter: number })[]} from
+* @param {({ peer: PeerID, counter: number })[]} to
+* @returns {VersionVectorDiff}
+*/
+  findIdSpansBetween(from: ({ peer: PeerID, counter: number })[], to: ({ peer: PeerID, counter: number })[]): VersionVectorDiff;
+/**
 * Checkout the `DocState` to a specific version.
 *
 * > The document becomes detached during a `checkout` operation.
@@ -1689,12 +1773,14 @@ export class LoroDoc {
 */
   setPeerId(peer_id: number | bigint | `${number}`): void;
 /**
-* Commit the cumulative auto committed transaction.
+* Commit the cumulative auto-committed transaction.
 *
 * You can specify the `origin`, `timestamp`, and `message` of the commit.
 *
 * - The `origin` is used to mark the event
 * - The `message` works like a git commit message, which will be recorded and synced to peers
+* - The `timestamp` is the number of seconds that have elapsed since 00:00:00 UTC on January 1, 1970.
+*   It defaults to `Date.now() / 1000` when timestamp recording is enabled
 *
 * The events will be emitted after a transaction is committed. A transaction is committed when:
 *
@@ -2014,7 +2100,7 @@ export class LoroDoc {
 *
 * @example
 * ```ts
-* import { LoroDoc, LoroText } from "loro-crdt";
+* import { LoroDoc, LoroText, LoroMap } from "loro-crdt";
 *
 * const doc = new LoroDoc();
 * const list = doc.getList("list");
@@ -2195,6 +2281,40 @@ export class LoroDoc {
 */
   getChangedContainersIn(id: { peer: PeerID, counter: number }, len: number): (ContainerID)[];
 /**
+* Revert the document to the given frontiers.
+*
+* The doc will not become detached when using this method. Instead, it will generate a series
+* of operations to revert the document to the given version.
+*
+* @example
+* ```ts
+* const doc = new LoroDoc();
+* doc.setPeerId("1");
+* const text = doc.getText("text");
+* text.insert(0, "Hello");
+* doc.commit();
+* doc.revertTo([{ peer: "1", counter: 1 }]);
+* expect(doc.getText("text").toString()).toBe("He");
+* ```
+* @param {({ peer: PeerID, counter: number })[]} frontiers
+*/
+  revertTo(frontiers: ({ peer: PeerID, counter: number })[]): void;
+/**
+* Apply a diff batch to the document
+* @param {Record<ContainerID, Diff>} diff
+*/
+  applyDiff(diff: Record<ContainerID, Diff>): void;
+/**
+* Calculate the differences between two frontiers
+*
+* The entries in the returned object are sorted by causal order: the creation of a child container will be
+* presented before its use.
+* @param {({ peer: PeerID, counter: number })[]} from
+* @param {({ peer: PeerID, counter: number })[]} to
+* @returns {Record<ContainerID, Diff>}
+*/
+  diff(from: ({ peer: PeerID, counter: number })[], to: ({ peer: PeerID, counter: number })[]): Record<ContainerID, Diff>;
+/**
 * Peer ID of the current writer.
 */
   readonly peerId: bigint;
@@ -2488,7 +2608,7 @@ export class LoroMap {
 *
 * @example
 * ```ts
-* import { LoroDoc } from "loro-crdt";
+* import { LoroDoc, LoroText } from "loro-crdt";
 *
 * const doc = new LoroDoc();
 * doc.setPeerId("1");
@@ -3365,6 +3485,7 @@ export class UndoManager {
   setMaxUndoSteps(steps: number): void;
 /**
 * Set the merge interval (in ms).
+*
 * If the interval is set to 0, the undo steps will not be merged.
 * Otherwise, the undo steps will be merged if the interval between the two steps is less than the given interval.
 * @param {number} interval

package/bundler/loro_wasm_bg.js

@@ -237,11 +237,11 @@ function makeMutClosure(arg0, arg1, dtor, f) {
     CLOSURE_DTORS.register(real, state, state);
     return real;
 }
-function __wbg_adapter_58(arg0, arg1, arg2) {
+function __wbg_adapter_60(arg0, arg1, arg2) {
     wasm.__wbindgen_export_3(arg0, arg1, addHeapObject(arg2));
 }
 
-function __wbg_adapter_61(arg0, arg1) {
+function __wbg_adapter_63(arg0, arg1) {
     wasm.__wbindgen_export_4(arg0, arg1);
 }
 
@@ -971,9 +971,12 @@ export class LoroDoc {
         wasm.lorodoc_setRecordTimestamp(this.__wbg_ptr, auto_record);
     }
     /**
-    * If two continuous local changes are within the interval, they will be merged into one change.
+    * If two continuous local changes are within (<=) the interval(**in seconds**), they will be merged into one change.
     *
-    * The default value is 1_000_000, the default unit is seconds.
+    * The default value is 1_000 seconds.
+    *
+    * By default, we record timestamps in seconds for each change. So if the merge interval is 1, and changes A and B
+    * have timestamps of 3 and 4 respectively, then they will be merged into one change
     * @param {number} interval
     */
     setChangeMergeInterval(interval) {
@@ -1237,6 +1240,72 @@ export class LoroDoc {
         }
     }
     /**
+    * Find the op id spans that between the `from` version and the `to` version.
+    *
+    * You can combine it with `exportJsonInIdSpan` to get the changes between two versions.
+    *
+    * You can use it to travel all the changes from `from` to `to`. `from` and `to` are frontiers,
+    * and they can be concurrent to each other. You can use it to find all the changes related to an event:
+    *
+    * @example
+    * ```ts
+    * import { LoroDoc } from "loro-crdt";
+    *
+    * const docA = new LoroDoc();
+    * docA.setPeerId("1");
+    * const docB = new LoroDoc();
+    *
+    * docA.getText("text").update("Hello");
+    * docA.commit();
+    * const snapshot = docA.export({ mode: "snapshot" });
+    * let done = false;
+    * docB.subscribe(e => {
+    *   const spans = docB.findIdSpansBetween(e.from, e.to);
+    *   const changes = docB.exportJsonInIdSpan(spans.forward[0]);
+    *   console.log(changes);
+    *   // [{
+    *   //   id: "0@1",
+    *   //   timestamp: expect.any(Number),
+    *   //   deps: [],
+    *   //   lamport: 0,
+    *   //   msg: undefined,
+    *   //   ops: [{
+    *   //     container: "cid:root-text:Text",
+    *   //     counter: 0,
+    *   //     content: {
+    *   //       type: "insert",
+    *   //       pos: 0,
+    *   //       text: "Hello"
+    *   //     }
+    *   //   }]
+    *   // }]
+    * });
+    * docB.import(snapshot);
+    * ```
+    * @param {({ peer: PeerID, counter: number })[]} from
+    * @param {({ peer: PeerID, counter: number })[]} to
+    * @returns {VersionVectorDiff}
+    */
+    findIdSpansBetween(from, to) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passArrayJsValueToWasm0(from, wasm.__wbindgen_export_0);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passArrayJsValueToWasm0(to, wasm.__wbindgen_export_0);
+            const len1 = WASM_VECTOR_LEN;
+            wasm.lorodoc_findIdSpansBetween(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1);
+            var r0 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            var r2 = getInt32Memory0()[retptr / 4 + 2];
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
     * Checkout the `DocState` to a specific version.
     *
     * > The document becomes detached during a `checkout` operation.
@@ -1315,12 +1384,14 @@ export class LoroDoc {
         }
     }
     /**
-    * Commit the cumulative auto committed transaction.
+    * Commit the cumulative auto-committed transaction.
     *
     * You can specify the `origin`, `timestamp`, and `message` of the commit.
     *
     * - The `origin` is used to mark the event
     * - The `message` works like a git commit message, which will be recorded and synced to peers
+    * - The `timestamp` is the number of seconds that have elapsed since 00:00:00 UTC on January 1, 1970.
+    *   It defaults to `Date.now() / 1000` when timestamp recording is enabled
     *
     * The events will be emitted after a transaction is committed. A transaction is committed when:
     *
@@ -1897,12 +1968,32 @@ export class LoroDoc {
     * Export updates in the given range in JSON format.
     * @param {any} start_vv
     * @param {any} end_vv
+    * @param {boolean | undefined} [with_peer_compression]
     * @returns {JsonSchema}
     */
-    exportJsonUpdates(start_vv, end_vv) {
+    exportJsonUpdates(start_vv, end_vv, with_peer_compression) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.lorodoc_exportJsonUpdates(retptr, this.__wbg_ptr, addHeapObject(start_vv), addHeapObject(end_vv), isLikeNone(with_peer_compression) ? 0xFFFFFF : with_peer_compression ? 1 : 0);
+            var r0 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            var r2 = getInt32Memory0()[retptr / 4 + 2];
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+    * @param {{ peer: PeerID, counter: number, length: number }} idSpan
+    * @returns {any}
+    */
+    exportJsonInIdSpan(idSpan) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.lorodoc_exportJsonUpdates(retptr, this.__wbg_ptr, addHeapObject(start_vv), addHeapObject(end_vv));
+            wasm.lorodoc_exportJsonInIdSpan(retptr, this.__wbg_ptr, addHeapObject(idSpan));
             var r0 = getInt32Memory0()[retptr / 4 + 0];
             var r1 = getInt32Memory0()[retptr / 4 + 1];
             var r2 = getInt32Memory0()[retptr / 4 + 2];
@@ -2101,7 +2192,7 @@ export class LoroDoc {
     *
     * @example
     * ```ts
-    * import { LoroDoc, LoroText } from "loro-crdt";
+    * import { LoroDoc, LoroText, LoroMap } from "loro-crdt";
     *
     * const doc = new LoroDoc();
     * const list = doc.getList("list");
@@ -2465,6 +2556,84 @@ export class LoroDoc {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
+    /**
+    * Revert the document to the given frontiers.
+    *
+    * The doc will not become detached when using this method. Instead, it will generate a series
+    * of operations to revert the document to the given version.
+    *
+    * @example
+    * ```ts
+    * const doc = new LoroDoc();
+    * doc.setPeerId("1");
+    * const text = doc.getText("text");
+    * text.insert(0, "Hello");
+    * doc.commit();
+    * doc.revertTo([{ peer: "1", counter: 1 }]);
+    * expect(doc.getText("text").toString()).toBe("He");
+    * ```
+    * @param {({ peer: PeerID, counter: number })[]} frontiers
+    */
+    revertTo(frontiers) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passArrayJsValueToWasm0(frontiers, wasm.__wbindgen_export_0);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.lorodoc_revertTo(retptr, this.__wbg_ptr, ptr0, len0);
+            var r0 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            if (r1) {
+                throw takeObject(r0);
+            }
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+    * Apply a diff batch to the document
+    * @param {Record<ContainerID, Diff>} diff
+    */
+    applyDiff(diff) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.lorodoc_applyDiff(retptr, this.__wbg_ptr, addHeapObject(diff));
+            var r0 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            if (r1) {
+                throw takeObject(r0);
+            }
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+    * Calculate the differences between two frontiers
+    *
+    * The entries in the returned object are sorted by causal order: the creation of a child container will be
+    * presented before its use.
+    * @param {({ peer: PeerID, counter: number })[]} from
+    * @param {({ peer: PeerID, counter: number })[]} to
+    * @returns {Record<ContainerID, Diff>}
+    */
+    diff(from, to) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passArrayJsValueToWasm0(from, wasm.__wbindgen_export_0);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passArrayJsValueToWasm0(to, wasm.__wbindgen_export_0);
+            const len1 = WASM_VECTOR_LEN;
+            wasm.lorodoc_diff(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1);
+            var r0 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            var r2 = getInt32Memory0()[retptr / 4 + 2];
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
 }
 
 const LoroListFinalization = (typeof FinalizationRegistry === 'undefined')
@@ -3362,7 +3531,7 @@ export class LoroMap {
     *
     * @example
     * ```ts
-    * import { LoroDoc } from "loro-crdt";
+    * import { LoroDoc, LoroText } from "loro-crdt";
     *
     * const doc = new LoroDoc();
     * doc.setPeerId("1");
@@ -5535,6 +5704,7 @@ export class UndoManager {
     }
     /**
     * Set the merge interval (in ms).
+    *
     * If the interval is set to 0, the undo steps will not be merged.
     * Otherwise, the undo steps will be merged if the interval between the two steps is less than the given interval.
     * @param {number} interval
@@ -5808,28 +5978,28 @@ export function __wbindgen_object_drop_ref(arg0) {
     takeObject(arg0);
 };
 
-export function __wbg_loromap_new(arg0) {
-    const ret = LoroMap.__wrap(arg0);
+export function __wbg_lorolist_new(arg0) {
+    const ret = LoroList.__wrap(arg0);
     return addHeapObject(ret);
 };
 
-export function __wbg_lorotext_new(arg0) {
-    const ret = LoroText.__wrap(arg0);
+export function __wbg_lorocounter_new(arg0) {
+    const ret = LoroCounter.__wrap(arg0);
     return addHeapObject(ret);
 };
 
-export function __wbg_lorolist_new(arg0) {
-    const ret = LoroList.__wrap(arg0);
+export function __wbg_loromap_new(arg0) {
+    const ret = LoroMap.__wrap(arg0);
     return addHeapObject(ret);
 };
 
-export function __wbg_lorotree_new(arg0) {
-    const ret = LoroTree.__wrap(arg0);
+export function __wbg_lorotreenode_new(arg0) {
+    const ret = LoroTreeNode.__wrap(arg0);
     return addHeapObject(ret);
 };
 
-export function __wbg_cursor_new(arg0) {
-    const ret = Cursor.__wrap(arg0);
+export function __wbg_lorotree_new(arg0) {
+    const ret = LoroTree.__wrap(arg0);
     return addHeapObject(ret);
 };
 
@@ -5838,13 +6008,13 @@ export function __wbg_loromovablelist_new(arg0) {
     return addHeapObject(ret);
 };
 
-export function __wbg_lorocounter_new(arg0) {
-    const ret = LoroCounter.__wrap(arg0);
+export function __wbg_cursor_new(arg0) {
+    const ret = Cursor.__wrap(arg0);
     return addHeapObject(ret);
 };
 
-export function __wbg_lorotreenode_new(arg0) {
-    const ret = LoroTreeNode.__wrap(arg0);
+export function __wbg_lorotext_new(arg0) {
+    const ret = LoroText.__wrap(arg0);
     return addHeapObject(ret);
 };
 
@@ -5961,6 +6131,11 @@ export function __wbindgen_number_new(arg0) {
     return addHeapObject(ret);
 };
 
+export function __wbindgen_is_array(arg0) {
+    const ret = Array.isArray(getObject(arg0));
+    return ret;
+};
+
 export function __wbindgen_typeof(arg0) {
     const ret = typeof getObject(arg0);
     return addHeapObject(ret);
@@ -6071,7 +6246,7 @@ export function __wbg_error_f851667af71bcfc6(arg0, arg1) {
     }
 };
 
-export const __wbg_now_11683c634f92ae89 = typeof Date.now == 'function' ? Date.now : notDefined('Date.now');
+export const __wbg_now_15d99db1ebc1f0b2 = typeof Date.now == 'function' ? Date.now : notDefined('Date.now');
 
 export function __wbg_crypto_1d1f22824a6a080c(arg0) {
     const ret = getObject(arg0).crypto;
@@ -6205,6 +6380,11 @@ export function __wbg_set_d4638f722068f043(arg0, arg1, arg2) {
     getObject(arg0)[arg1 >>> 0] = takeObject(arg2);
 };
 
+export function __wbg_from_89e3fc3ba5e6fb48(arg0) {
+    const ret = Array.from(getObject(arg0));
+    return addHeapObject(ret);
+};
+
 export function __wbg_isArray_2ab64d95e09ea0ae(arg0) {
     const ret = Array.isArray(getObject(arg0));
     return ret;
@@ -6390,13 +6570,13 @@ export function __wbindgen_memory() {
     return addHeapObject(ret);
 };
 
-export function __wbindgen_closure_wrapper487(arg0, arg1, arg2) {
-    const ret = makeMutClosure(arg0, arg1, 9, __wbg_adapter_58);
+export function __wbindgen_closure_wrapper491(arg0, arg1, arg2) {
+    const ret = makeMutClosure(arg0, arg1, 9, __wbg_adapter_60);
     return addHeapObject(ret);
 };
 
-export function __wbindgen_closure_wrapper489(arg0, arg1, arg2) {
-    const ret = makeMutClosure(arg0, arg1, 11, __wbg_adapter_61);
+export function __wbindgen_closure_wrapper494(arg0, arg1, arg2) {
+    const ret = makeMutClosure(arg0, arg1, 11, __wbg_adapter_63);
     return addHeapObject(ret);
 };
 

package/bundler/loro_wasm_bg.wasm.d.ts

@@ -44,6 +44,7 @@ export function lorodoc_fork(a: number): number;
 export function lorodoc_forkAt(a: number, b: number, c: number, d: number): void;
 export function lorodoc_checkoutToLatest(a: number, b: number): void;
 export function lorodoc_travelChangeAncestors(a: number, b: number, c: number, d: number, e: number): void;
+export function lorodoc_findIdSpansBetween(a: number, b: number, c: number, d: number, e: number, f: number): void;
 export function lorodoc_checkout(a: number, b: number, c: number, d: number): void;
 export function lorodoc_peerId(a: number): number;
 export function lorodoc_peerIdStr(a: number): number;
@@ -73,7 +74,8 @@ export function lorodoc_cmpFrontiers(a: number, b: number, c: number, d: number,
 export function lorodoc_exportSnapshot(a: number, b: number): void;
 export function lorodoc_exportFrom(a: number, b: number, c: number): void;
 export function lorodoc_export(a: number, b: number, c: number): void;
-export function lorodoc_exportJsonUpdates(a: number, b: number, c: number, d: number): void;
+export function lorodoc_exportJsonUpdates(a: number, b: number, c: number, d: number, e: number): void;
+export function lorodoc_exportJsonInIdSpan(a: number, b: number, c: number): void;
 export function lorodoc_importJsonUpdates(a: number, b: number, c: number): void;
 export function lorodoc_import(a: number, b: number, c: number, d: number): void;
 export function lorodoc_importUpdateBatch(a: number, b: number, c: number): void;
@@ -94,6 +96,9 @@ export function lorodoc_vvToFrontiers(a: number, b: number, c: number): void;
 export function lorodoc_getByPath(a: number, b: number, c: number): number;
 export function lorodoc_getCursorPos(a: number, b: number, c: number): void;
 export function lorodoc_getChangedContainersIn(a: number, b: number, c: number, d: number): void;
+export function lorodoc_revertTo(a: number, b: number, c: number, d: number): void;
+export function lorodoc_applyDiff(a: number, b: number, c: number): void;
+export function lorodoc_diff(a: number, b: number, c: number, d: number, e: number, f: number): void;
 export function __wbg_lorotext_free(a: number): void;
 export function lorotext_new(): number;
 export function lorotext_kind(a: number): number;