loro-crdt 1.8.9 → 1.9.0

package/base64/loro_wasm.d.ts

@@ -1,30 +1,6 @@
 /* tslint:disable */
 /* eslint-disable */
-/**
- * Get the version of Loro
- */
-export function LORO_VERSION(): string;
-export function run(): void;
-export function encodeFrontiers(frontiers: ({ peer: PeerID, counter: number })[]): Uint8Array;
-export function decodeFrontiers(bytes: Uint8Array): { peer: PeerID, counter: number }[];
-/**
- * Enable debug info of Loro
- */
-export function setDebug(): void;
 export function callPendingEvents(): void;
-/**
- * Decode the metadata of the import blob.
- *
- * This method is useful to get the following metadata of the import blob:
- *
- * - startVersionVector
- * - endVersionVector
- * - startTimestamp
- * - endTimestamp
- * - mode
- * - changeNum
- */
-export function decodeImportBlobMeta(blob: Uint8Array, check_checksum: boolean): ImportBlobMetadata;
 /**
  * Redacts sensitive content in JSON updates within the specified version range.
  *
@@ -45,6 +21,30 @@ export function decodeImportBlobMeta(blob: Uint8Array, check_checksum: boolean):
  * @returns {Object} The redacted JSON updates
  */
 export function redactJsonUpdates(json_updates: string | JsonSchema, version_range: any): JsonSchema;
+export function run(): void;
+/**
+ * Decode the metadata of the import blob.
+ *
+ * This method is useful to get the following metadata of the import blob:
+ *
+ * - startVersionVector
+ * - endVersionVector
+ * - startTimestamp
+ * - endTimestamp
+ * - mode
+ * - changeNum
+ */
+export function decodeImportBlobMeta(blob: Uint8Array, check_checksum: boolean): ImportBlobMetadata;
+/**
+ * Get the version of Loro
+ */
+export function LORO_VERSION(): string;
+export function decodeFrontiers(bytes: Uint8Array): { peer: PeerID, counter: number }[];
+export function encodeFrontiers(frontiers: ({ peer: PeerID, counter: number })[]): Uint8Array;
+/**
+ * Enable debug info of Loro
+ */
+export function setDebug(): void;
 
 /**
 * Container types supported by loro.
@@ -85,27 +85,6 @@ export type ContainerID =
 export type TreeID = `${number}@${PeerID}`;
 
 interface LoroDoc {
-    /**
-     * Export updates from the specific version to the current version
-     *
-     * @deprecated Use `export({mode: "update", from: version})` instead
-     *
-     *  @example
-     *  ```ts
-     *  import { LoroDoc } from "loro-crdt";
-     *
-     *  const doc = new LoroDoc();
-     *  const text = doc.getText("text");
-     *  text.insert(0, "Hello");
-     *  // get all updates of the doc
-     *  const updates = doc.exportFrom();
-     *  const version = doc.oplogVersion();
-     *  text.insert(5, " World");
-     *  // get updates from specific version to the latest version
-     *  const updates2 = doc.exportFrom(version);
-     *  ```
-     */
-    exportFrom(version?: VersionVector): Uint8Array;
     /**
      *
      *  Get the container corresponding to the container id
@@ -1451,6 +1430,14 @@ interface EphemeralStoreEvent {
  */
 export class AwarenessWasm {
   free(): void;
+  /**
+   * Get the timestamp of the state of a given peer.
+   */
+  getTimestamp(peer: number | bigint | `${number}`): number | undefined;
+  /**
+   * Remove the states of outdated peers.
+   */
+  removeOutdated(): PeerID[];
   /**
    * Creates a new `Awareness` instance.
    *
@@ -1460,13 +1447,9 @@ export class AwarenessWasm {
    */
   constructor(peer: number | bigint | `${number}`, timeout: number);
   /**
-   * Encodes the state of the given peers.
-   */
-  encode(peers: Array<any>): Uint8Array;
-  /**
-   * Encodes the state of all peers.
+   * Get the PeerID of the local peer.
    */
-  encodeAll(): Uint8Array;
+  peer(): PeerID;
   /**
    * Applies the encoded state of peers.
    *
@@ -1475,17 +1458,13 @@ export class AwarenessWasm {
    */
   apply(encoded_peers_info: Uint8Array): { updated: PeerID[], added: PeerID[] };
   /**
-   * Get the PeerID of the local peer.
-   */
-  peer(): PeerID;
-  /**
-   * Get the timestamp of the state of a given peer.
+   * Get all the peers
    */
-  getTimestamp(peer: number | bigint | `${number}`): number | undefined;
+  peers(): PeerID[];
   /**
-   * Remove the states of outdated peers.
+   * Encodes the state of the given peers.
    */
-  removeOutdated(): PeerID[];
+  encode(peers: Array<any>): Uint8Array;
   /**
    * Get the number of peers.
    */
@@ -1495,9 +1474,9 @@ export class AwarenessWasm {
    */
   isEmpty(): boolean;
   /**
-   * Get all the peers
+   * Encodes the state of all peers.
    */
-  peers(): PeerID[];
+  encodeAll(): Uint8Array;
 }
 export class ChangeModifier {
   private constructor();
@@ -1552,24 +1531,27 @@ export class Cursor {
    */
   pos(): { peer: PeerID, counter: number } | undefined;
   /**
-   * Get which side of the character/list item the cursor is on.
+   * "Cursor"
    */
-  side(): Side;
+  kind(): any;
   /**
-   * Encode the cursor into a Uint8Array.
+   * Get which side of the character/list item the cursor is on.
    */
-  encode(): Uint8Array;
+  side(): Side;
   /**
    * Decode the cursor from a Uint8Array.
    */
   static decode(data: Uint8Array): Cursor;
   /**
-   * "Cursor"
+   * Encode the cursor into a Uint8Array.
    */
-  kind(): any;
+  encode(): Uint8Array;
 }
 export class EphemeralStoreWasm {
   free(): void;
+  getAllStates(): any;
+  removeOutdated(): void;
+  get(key: string): any;
   /**
    * Creates a new `EphemeralStore` instance.
    *
@@ -1579,18 +1561,15 @@ export class EphemeralStoreWasm {
    */
   constructor(timeout: number);
   set(key: string, value: any): void;
+  keys(): string[];
+  apply(data: Uint8Array): void;
   delete(key: string): void;
-  get(key: string): any;
-  getAllStates(): any;
   encode(key: string): Uint8Array;
-  encodeAll(): Uint8Array;
-  apply(data: Uint8Array): void;
-  removeOutdated(): void;
   /**
    * If the state is empty.
    */
   isEmpty(): boolean;
-  keys(): string[];
+  encodeAll(): Uint8Array;
 }
 /**
  * The handler of a counter container.
@@ -1598,25 +1577,29 @@ export class EphemeralStoreWasm {
 export class LoroCounter {
   free(): void;
   /**
-   * Create a new LoroCounter.
+   * Whether the container is attached to a docuemnt.
+   *
+   * If it's detached, the operations on the container will not be persisted.
    */
-  constructor();
+  isAttached(): boolean;
   /**
-   * "Counter"
+   * Get the attached container associated with this.
+   *
+   * Returns an attached `Container` that equals to this or created by this, otherwise `undefined`.
    */
-  kind(): 'Counter';
+  getAttached(): LoroTree | undefined;
   /**
-   * Increment the counter by the given value.
+   * Get the value of the counter.
    */
-  increment(value: number): void;
+  getShallowValue(): number;
   /**
-   * Decrement the counter by the given value.
+   * Create a new LoroCounter.
    */
-  decrement(value: number): void;
+  constructor();
   /**
-   * Subscribe to the changes of the counter.
+   * "Counter"
    */
-  subscribe(f: Function): any;
+  kind(): 'Counter';
   /**
    * Get the parent container of the counter container.
    *
@@ -1625,23 +1608,19 @@ export class LoroCounter {
    *   the WASM boundary.
    */
   parent(): Container | undefined;
+  toJSON(): number;
   /**
-   * Whether the container is attached to a docuemnt.
-   *
-   * If it's detached, the operations on the container will not be persisted.
+   * Decrement the counter by the given value.
    */
-  isAttached(): boolean;
+  decrement(value: number): void;
   /**
-   * Get the attached container associated with this.
-   *
-   * Returns an attached `Container` that equals to this or created by this, otherwise `undefined`.
+   * Increment the counter by the given value.
    */
-  getAttached(): LoroTree | undefined;
+  increment(value: number): void;
   /**
-   * Get the value of the counter.
+   * Subscribe to the changes of the counter.
    */
-  getShallowValue(): number;
-  toJSON(): number;
+  subscribe(f: Function): any;
   /**
    * The container id of this handler.
    */
@@ -1674,147 +1653,77 @@ export class LoroCounter {
 export class LoroDoc {
   free(): void;
   /**
-   * Create a new loro document.
-   *
-   * New document will have a random peer id.
-   */
-  constructor();
-  /**
-   * Enables editing in detached mode, which is disabled by default.
+   * Apply a batch of diff to the document
    *
-   * The doc enter detached mode after calling `detach` or checking out a non-latest version.
+   * A diff batch represents a set of changes between two versions of the document.
+   * You can calculate a diff batch using `doc.diff()`.
    *
-   * # Important Notes:
+   * Changes are associated with container IDs. During diff application, if new containers were created in the source
+   * document, they will be assigned fresh IDs in the target document. Loro automatically handles remapping these
+   * container IDs from their original IDs to the new IDs as the diff is applied.
    *
-   * - This mode uses a different PeerID for each checkout.
-   * - Ensure no concurrent operations share the same PeerID if set manually.
-   * - Importing does not affect the document's state or version; changes are
-   *   recorded in the [OpLog] only. Call `checkout` to apply changes.
-   */
-  setDetachedEditing(enable: boolean): void;
-  /**
-   * Whether the editing is enabled in detached mode.
+   * @example
+   * ```ts
+   * const doc1 = new LoroDoc();
+   * const doc2 = new LoroDoc();
    *
-   * The doc enter detached mode after calling `detach` or checking out a non-latest version.
+   * // Make some changes to doc1
+   * const text = doc1.getText("text");
+   * text.insert(0, "Hello");
    *
-   * # Important Notes:
+   * // Calculate diff between empty and current state
+   * const diff = doc1.diff([], doc1.frontiers());
    *
-   * - This mode uses a different PeerID for each checkout.
-   * - Ensure no concurrent operations share the same PeerID if set manually.
-   * - Importing does not affect the document's state or version; changes are
-   *   recorded in the [OpLog] only. Call `checkout` to apply changes.
+   * // Apply changes to doc2
+   * doc2.applyDiff(diff);
+   * console.log(doc2.getText("text").toString()); // "Hello"
+   * ```
    */
-  isDetachedEditingEnabled(): boolean;
+  applyDiff(diff: [ContainerID, Diff|JsonDiff][]): void;
   /**
-   * Set whether to record the timestamp of each change. Default is `false`.
-   *
-   * If enabled, the Unix timestamp (in seconds) will be recorded for each change automatically.
-   *
-   * You can also set each timestamp manually when you commit a change.
-   * The timestamp manually set will override the automatic one.
-   *
-   * NOTE: Timestamps are forced to be in ascending order in the OpLog's history.
-   * If you commit a new change with a timestamp that is less than the existing one,
-   * the largest existing timestamp will be used instead.
+   * Check if the doc contains the full history.
    */
-  setRecordTimestamp(auto_record: boolean): void;
+  isShallow(): boolean;
   /**
-   * 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.
-   *
-   * 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
+   * Get the number of changes in the oplog.
    */
-  setChangeMergeInterval(interval: number): void;
+  changeCount(): number;
   /**
-   * Set the rich text format configuration of the document.
+   * Get the value or container at the given path
    *
-   * You need to config it if you use rich text `mark` method.
-   * Specifically, you need to config the `expand` property of each style.
+   * The path can be specified in different ways depending on the container type:
    *
-   * Expand is used to specify the behavior of expanding when new text is inserted at the
-   * beginning or end of the style.
+   * For Tree:
+   * 1. Using node IDs: `tree/{node_id}/property`
+   * 2. Using indices: `tree/0/1/property`
    *
-   * You can specify the `expand` option to set the behavior when inserting text at the boundary of the range.
+   * For List and MovableList:
+   * - Using indices: `list/0` or `list/1/property`
    *
-   * - `after`(default): when inserting text right after the given range, the mark will be expanded to include the inserted text
-   * - `before`: when inserting text right before the given range, the mark will be expanded to include the inserted text
-   * - `none`: the mark will not be expanded to include the inserted text at the boundaries
-   * - `both`: when inserting text either right before or right after the given range, the mark will be expanded to include the inserted text
+   * For Map:
+   * - Using keys: `map/key` or `map/nested/property`
+   *
+   * For tree structures, index-based paths follow depth-first traversal order.
+   * The indices start from 0 and represent the position of a node among its siblings.
    *
    * @example
    * ```ts
+   * import { LoroDoc } from "loro-crdt";
+   *
    * const doc = new LoroDoc();
-   * doc.configTextStyle({
-   *   bold: { expand: "after" },
-   *   link: { expand: "before" }
-   * });
-   * const text = doc.getText("text");
-   * text.insert(0, "Hello World!");
-   * text.mark({ start: 0, end: 5 }, "bold", true);
-   * expect(text.toDelta()).toStrictEqual([
-   *   {
-   *     insert: "Hello",
-   *     attributes: {
-   *       bold: true,
-   *     },
-   *   },
-   *   {
-   *     insert: " World!",
-   *   },
-   * ] as Delta<string>[]);
-   * ```
-   */
-  configTextStyle(styles: {[key: string]: { expand: 'before'|'after'|'none'|'both' }}): void;
-  /**
-   * Configures the default text style for the document.
-   *
-   * This method sets the default text style configuration for the document when using LoroText.
-   * If `None` is provided, the default style is reset.
-   */
-  configDefaultTextStyle(style: { expand: 'before'|'after'|'none'|'both' } | undefined): void;
-  /**
-   * Create a loro document from the snapshot.
-   *
-   * @see You can learn more [here](https://loro.dev/docs/tutorial/encoding).
-   *
-   * @example
-   * ```ts
-   * import { LoroDoc } from "loro-crdt"
-   *
-   * const doc = new LoroDoc();
-   * // ...
-   * const bytes = doc.export({ mode: "snapshot" });
-   * const loro = LoroDoc.fromSnapshot(bytes);
+   * const map = doc.getMap("map");
+   * map.set("key", 1);
+   * console.log(doc.getByPath("map/key")); // 1
+   * console.log(doc.getByPath("map"));     // LoroMap
    * ```
    */
-  static fromSnapshot(snapshot: Uint8Array): LoroDoc;
+  getByPath(path: string): Value | Container | undefined;
   /**
-   * Attach the document state to the latest known version.
-   *
-   * > The document becomes detached during a `checkout` operation.
-   * > Being `detached` implies that the `DocState` is not synchronized with the latest version of the `OpLog`.
-   * > In a detached state, the document is not editable, and any `import` operations will be
-   * > recorded in the `OpLog` without being applied to the `DocState`.
-   *
-   * This method has the same effect as invoking `checkoutToLatest`.
-   *
-   * @example
-   * ```ts
-   * import { LoroDoc } from "loro-crdt";
+   * Get a LoroCounter by container id
    *
-   * const doc = new LoroDoc();
-   * const text = doc.getText("text");
-   * const frontiers = doc.frontiers();
-   * text.insert(0, "Hello World!");
-   * doc.checkout(frontiers);
-   * // you need call `attach()` or `checkoutToLatest()` before changing the doc.
-   * doc.attach();
-   * text.insert(0, "Hi");
-   * ```
+   * If the container does not exist, an error will be thrown.
    */
-  attach(): void;
+  getCounter(cid: ContainerID | string): LoroCounter;
   /**
    * `detached` indicates that the `DocState` is not synchronized with the latest version of `OpLog`.
    *
@@ -1840,45 +1749,67 @@ export class LoroDoc {
    */
   isDetached(): boolean;
   /**
-   * Detach the document state from the latest known version.
+   * Set the peer ID of the current writer.
    *
-   * After detaching, all import operations will be recorded in the `OpLog` without being applied to the `DocState`.
-   * When `detached`, the document is not editable.
+   * It must be a number, a BigInt, or a decimal string that can be parsed to a unsigned 64-bit integer.
+   *
+   * Note: use it with caution. You need to make sure there is not chance that two peers
+   * have the same peer ID. Otherwise, we cannot ensure the consistency of the document.
+   */
+  setPeerId(peer_id: number | bigint | `${number}`): void;
+  /**
+   * Get the absolute position of the given Cursor
    *
    * @example
    * ```ts
-   * import { LoroDoc } from "loro-crdt";
-   *
    * const doc = new LoroDoc();
-   * doc.detach();
-   * console.log(doc.isDetached());  // true
+   * const text = doc.getText("text");
+   * text.insert(0, "123");
+   * const pos0 = text.getCursor(0, 0);
+   * {
+   *    const ans = doc.getCursorPos(pos0!);
+   *    expect(ans.offset).toBe(0);
+   * }
+   * text.insert(0, "1");
+   * {
+   *    const ans = doc.getCursorPos(pos0!);
+   *    expect(ans.offset).toBe(1);
+   * }
    * ```
    */
-  detach(): void;
+  getCursorPos(cursor: Cursor): { update?: Cursor, offset: number, side: Side } | undefined;
   /**
-   * Duplicate the document with a different PeerID
+   * Check if the doc contains the target container.
    *
-   * The time complexity and space complexity of this operation are both O(n),
+   * A root container always exists, while a normal container exists
+   * if it has ever been created on the doc.
    *
-   * When called in detached mode, it will fork at the current state frontiers.
-   * It will have the same effect as `forkAt(&self.frontiers())`.
-   */
-  fork(): LoroDoc;
-  /**
-   * Creates a new LoroDoc at a specified version (Frontiers)
+   * @example
+   * ```ts
+   * import { LoroDoc, LoroMap, LoroText, LoroList } from "loro-crdt";
    *
-   * The created doc will only contain the history before the specified frontiers.
+   * const doc = new LoroDoc();
+   * doc.setPeerId("1");
+   * const text = doc.getMap("map").setContainer("text", new LoroText());
+   * const list = doc.getMap("map").setContainer("list", new LoroList());
+   * expect(doc.isContainerExists("cid:root-map:Map")).toBe(true);
+   * expect(doc.isContainerExists("cid:0@1:Text")).toBe(true);
+   * expect(doc.isContainerExists("cid:1@1:List")).toBe(true);
+   *
+   * const doc2 = new LoroDoc();
+   * // Containers exist, as long as the history or the doc state include it
+   * doc.detach();
+   * doc2.import(doc.export({ mode: "update" }));
+   * expect(doc2.isContainerExists("cid:root-map:Map")).toBe(true);
+   * expect(doc2.isContainerExists("cid:0@1:Text")).toBe(true);
+   * expect(doc2.isContainerExists("cid:1@1:List")).toBe(true);
+   * ```
    */
-  forkAt(frontiers: ({ peer: PeerID, counter: number })[]): LoroDoc;
+  hasContainer(container_id: ContainerID): boolean;
   /**
-   * Checkout the `DocState` to the latest version of `OpLog`.
-   *
-   * > The document becomes detached during a `checkout` operation.
-   * > Being `detached` implies that the `DocState` is not synchronized with the latest version of the `OpLog`.
-   * > In a detached state, the document is not editable by default, and any `import` operations will be
-   * > recorded in the `OpLog` without being applied to the `DocState`.
+   * Import a batch of updates or snapshots.
    *
-   * This has the same effect as `attach`.
+   * It's more efficient than importing updates one by one.
    *
    * @example
    * ```ts
@@ -1886,78 +1817,61 @@ export class LoroDoc {
    *
    * const doc = new LoroDoc();
    * const text = doc.getText("text");
-   * const frontiers = doc.frontiers();
-   * text.insert(0, "Hello World!");
-   * doc.checkout(frontiers);
-   * // you need call `checkoutToLatest()` or `attach()` before changing the doc.
-   * doc.checkoutToLatest();
-   * text.insert(0, "Hi");
+   * text.insert(0, "Hello");
+   * const updates = doc.export({ mode: "update" });
+   * const snapshot = doc.export({ mode: "snapshot" });
+   * const doc2 = new LoroDoc();
+   * doc2.importBatch([snapshot, updates]);
    * ```
    */
-  checkoutToLatest(): void;
+  importBatch(data: Uint8Array[]): ImportStatus;
   /**
-   * Visit all the ancestors of the changes in causal order.
+   * Compare the ordering of two Frontiers.
    *
-   * @param ids - the changes to visit
-   * @param f - the callback function, return `true` to continue visiting, return `false` to stop
+   * It's assumed that both Frontiers are included by the doc. Otherwise, an error will be thrown.
+   *
+   * Return value:
+   *
+   * - -1: a < b
+   * - 0: a == b
+   * - 1: a > b
+   * - undefined: a ∥ b: a and b are concurrent
    */
-  travelChangeAncestors(ids: ({ peer: PeerID, counter: number })[], f: (change: Change) => boolean): void;
+  cmpFrontiers(a: ({ peer: PeerID, counter: number })[], b: ({ peer: PeerID, counter: number })[]): -1 | 1 | 0 | undefined;
   /**
-   * 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.
+   * Debug the size of the history
+   */
+  debugHistory(): void;
+  /**
+   * Create a loro document from the snapshot.
    *
-   * 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:
+   * @see You can learn more [here](https://loro.dev/docs/tutorial/encoding).
    *
    * @example
    * ```ts
-   * import { LoroDoc } from "loro-crdt";
-   *
-   * const docA = new LoroDoc();
-   * docA.setPeerId("1");
-   * const docB = new LoroDoc();
+   * import { LoroDoc } from "loro-crdt"
    *
-   * 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);
+   * const doc = new LoroDoc();
+   * // ...
+   * const bytes = doc.export({ mode: "snapshot" });
+   * const loro = LoroDoc.fromSnapshot(bytes);
    * ```
    */
-  findIdSpansBetween(from: ({ peer: PeerID, counter: number })[], to: ({ peer: PeerID, counter: number })[]): VersionVectorDiff;
+  static fromSnapshot(snapshot: Uint8Array): LoroDoc;
   /**
-   * Checkout the `DocState` to a specific version.
-   *
-   * > The document becomes detached during a `checkout` operation.
-   * > Being `detached` implies that the `DocState` is not synchronized with the latest version of the `OpLog`.
-   * > In a detached state, the document is not editable, and any `import` operations will be
-   * > recorded in the `OpLog` without being applied to the `DocState`.
+   * Get the change that contains the specific ID
+   */
+  getChangeAt(id: { peer: PeerID, counter: number }): Change;
+  /**
+   * Get the version vector of the latest known version in OpLog.
    *
-   * You should call `attach` to attach the `DocState` to the latest version of `OpLog`.
+   * If you checkout to a specific version, this version vector will not change.
+   */
+  oplogVersion(): VersionVector;
+  /**
+   * Convert frontiers to a version vector
    *
-   * @param frontiers - the specific frontiers
+   * Learn more about frontiers and version vector [here](https://loro.dev/docs/advanced/version_deep_dive)
    *
    * @example
    * ```ts
@@ -1965,67 +1879,43 @@ export class LoroDoc {
    *
    * const doc = new LoroDoc();
    * const text = doc.getText("text");
+   * text.insert(0, "Hello");
    * const frontiers = doc.frontiers();
-   * text.insert(0, "Hello World!");
-   * doc.checkout(frontiers);
-   * console.log(doc.toJSON()); // {"text": ""}
+   * const version = doc.frontiersToVV(frontiers);
    * ```
    */
-  checkout(frontiers: ({ peer: PeerID, counter: number })[]): void;
+  frontiersToVV(frontiers: ({ peer: PeerID, counter: number })[]): VersionVector;
   /**
-   * Set the peer ID of the current writer.
+   * Get all of changes in the oplog.
    *
-   * It must be a number, a BigInt, or a decimal string that can be parsed to a unsigned 64-bit integer.
+   * Note: this method is expensive when the oplog is large. O(n)
    *
-   * Note: use it with caution. You need to make sure there is not chance that two peers
-   * have the same peer ID. Otherwise, we cannot ensure the consistency of the document.
-   */
-  setPeerId(peer_id: number | bigint | `${number}`): void;
-  /**
-   * Commit the cumulative auto-committed transaction.
+   * @example
+   * ```ts
+   * import { LoroDoc, LoroText } from "loro-crdt";
    *
-   * You can specify the `origin`, `timestamp`, and `message` of the commit.
+   * const doc = new LoroDoc();
+   * const text = doc.getText("text");
+   * text.insert(0, "Hello");
+   * const changes = doc.getAllChanges();
    *
-   * - 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:
-   *
-   * - `doc.commit()` is called.
-   * - `doc.export(mode)` is called.
-   * - `doc.import(data)` is called.
-   * - `doc.checkout(version)` is called.
-   *
-   * NOTE: Timestamps are forced to be in ascending order.
-   * If you commit a new change with a timestamp that is less than the existing one,
-   * the largest existing timestamp will be used instead.
-   *
-   * NOTE: The `origin` will not be persisted, but the `message` will.
-   *
-   * Behavior on empty commits:
-   * - This method is an explicit commit. If the pending transaction is empty, any provided
-   *   options (message/timestamp/origin) are swallowed and will not carry over to the next commit.
-   * - Implicit commits triggered by `export`/`checkout` act as processing barriers. If the
-   *   transaction is empty in those cases, `message`/`timestamp`/`origin` are preserved for the
-   *   next commit.
+   * for (let [peer, c] of changes.entries()){
+   *     console.log("peer: ", peer);
+   *     for (let change of c){
+   *         console.log("change: ", change);
+   *     }
+   * }
+   * ```
    */
-  commit(options?: { origin?: string, timestamp?: number, message?: string } | null): void;
+  getAllChanges(): Map<PeerID, Change[]>;
   /**
-   * Get the number of operations in the pending transaction.
+   * Get the [frontiers](https://loro.dev/docs/advanced/version_deep_dive) of the latest version in OpLog.
    *
-   * The pending transaction is the one that is not committed yet. It will be committed
-   * automatically after calling `doc.commit()`, `doc.export(mode)` or `doc.checkout(version)`.
+   * If you checkout to a specific version, this value will not change.
    */
-  getPendingTxnLength(): number;
+  oplogFrontiers(): { peer: PeerID, counter: number }[];
   /**
-   * Get a LoroText by container id.
-   *
-   * The object returned is a new js object each time because it need to cross
-   * the WASM boundary.
-   *
-   * If the container does not exist, an error will be thrown.
+   * Convert a version vector to frontiers
    *
    * @example
    * ```ts
@@ -2033,119 +1923,116 @@ export class LoroDoc {
    *
    * const doc = new LoroDoc();
    * const text = doc.getText("text");
+   * text.insert(0, "Hello");
+   * const version = doc.version();
+   * const frontiers = doc.vvToFrontiers(version);
    * ```
    */
-  getText(cid: ContainerID | string): LoroText;
+  vvToFrontiers(vv: VersionVector): { peer: PeerID, counter: number }[];
   /**
-   * Get a LoroCounter by container id
+   * The doc only contains the history since this version
    *
-   * If the container does not exist, an error will be thrown.
+   * This is empty if the doc is not shallow.
+   *
+   * The ops included by the shallow history start version vector are not in the doc.
    */
-  getCounter(cid: ContainerID | string): LoroCounter;
+  shallowSinceVV(): VersionVector;
   /**
-   * Check if the doc contains the target container.
+   * Set the rich text format configuration of the document.
    *
-   * A root container always exists, while a normal container exists
-   * if it has ever been created on the doc.
+   * You need to config it if you use rich text `mark` method.
+   * Specifically, you need to config the `expand` property of each style.
+   *
+   * Expand is used to specify the behavior of expanding when new text is inserted at the
+   * beginning or end of the style.
+   *
+   * You can specify the `expand` option to set the behavior when inserting text at the boundary of the range.
+   *
+   * - `after`(default): when inserting text right after the given range, the mark will be expanded to include the inserted text
+   * - `before`: when inserting text right before the given range, the mark will be expanded to include the inserted text
+   * - `none`: the mark will not be expanded to include the inserted text at the boundaries
+   * - `both`: when inserting text either right before or right after the given range, the mark will be expanded to include the inserted text
    *
    * @example
    * ```ts
-   * import { LoroDoc, LoroMap, LoroText, LoroList } from "loro-crdt";
-   *
    * const doc = new LoroDoc();
-   * doc.setPeerId("1");
-   * const text = doc.getMap("map").setContainer("text", new LoroText());
-   * const list = doc.getMap("map").setContainer("list", new LoroList());
-   * expect(doc.isContainerExists("cid:root-map:Map")).toBe(true);
-   * expect(doc.isContainerExists("cid:0@1:Text")).toBe(true);
-   * expect(doc.isContainerExists("cid:1@1:List")).toBe(true);
-   *
-   * const doc2 = new LoroDoc();
-   * // Containers exist, as long as the history or the doc state include it
-   * doc.detach();
-   * doc2.import(doc.export({ mode: "update" }));
-   * expect(doc2.isContainerExists("cid:root-map:Map")).toBe(true);
-   * expect(doc2.isContainerExists("cid:0@1:Text")).toBe(true);
-   * expect(doc2.isContainerExists("cid:1@1:List")).toBe(true);
+   * doc.configTextStyle({
+   *   bold: { expand: "after" },
+   *   link: { expand: "before" }
+   * });
+   * const text = doc.getText("text");
+   * text.insert(0, "Hello World!");
+   * text.mark({ start: 0, end: 5 }, "bold", true);
+   * expect(text.toDelta()).toStrictEqual([
+   *   {
+   *     insert: "Hello",
+   *     attributes: {
+   *       bold: true,
+   *     },
+   *   },
+   *   {
+   *     insert: " World!",
+   *   },
+   * ] as Delta<string>[]);
    * ```
    */
-  hasContainer(container_id: ContainerID): boolean;
-  /**
-   * Set the commit message of the next commit
-   */
-  setNextCommitMessage(msg: string): void;
-  /**
-   * Set the origin of the next commit
-   */
-  setNextCommitOrigin(origin: string): void;
-  /**
-   * Set the timestamp of the next commit
-   */
-  setNextCommitTimestamp(timestamp: number): void;
-  /**
-   * Set the options of the next commit
-   */
-  setNextCommitOptions(options: { origin?: string, timestamp?: number, message?: string }): void;
-  /**
-   * Clear the options of the next commit
-   */
-  clearNextCommitOptions(): void;
-  /**
-   * Get deep value of the document with container id
-   */
-  getDeepValueWithID(): any;
-  /**
-   * Get the path from the root to the container
-   */
-  getPathToContainer(id: ContainerID): (string|number)[] | undefined;
-  /**
-   * Evaluate JSONPath against a LoroDoc
-   */
-  JSONPath(jsonpath: string): Array<any>;
+  configTextStyle(styles: {[key: string]: { expand: 'before'|'after'|'none'|'both' }}): void;
   /**
-   * Get the version vector of the current document state.
-   *
-   * If you checkout to a specific version, the version vector will change.
+   * Get all ops of the change that contains the specific ID
    */
-  version(): VersionVector;
+  getOpsInChange(id: { peer: PeerID, counter: number }): any[];
   /**
-   * The doc only contains the history since this version
+   * Get the shallow json format of the document state.
    *
-   * This is empty if the doc is not shallow.
+   * Unlike `toJSON()` which recursively resolves all containers to their values,
+   * `getShallowValue()` returns container IDs as strings for any nested containers.
    *
-   * The ops included by the shallow history start version vector are not in the doc.
-   */
-  shallowSinceVV(): VersionVector;
-  /**
-   * Check if the doc contains the full history.
-   */
-  isShallow(): boolean;
-  /**
-   * The doc only contains the history since this version
+   * @example
+   * ```ts
+   * import { LoroDoc } from "loro-crdt";
    *
-   * This is empty if the doc is not shallow.
+   * const doc = new LoroDoc();
+   * const list = doc.getList("list");
+   * const tree = doc.getTree("tree");
+   * const map = doc.getMap("map");
+   * const shallowValue = doc.getShallowValue();
+   * console.log(shallowValue);
+   * // {
+   * //   list: 'cid:root-list:List',
+   * //   tree: 'cid:root-tree:Tree',
+   * //   map: 'cid:root-map:Map'
+   * // }
    *
-   * The ops included by the shallow history start frontiers are not in the doc.
+   * // It points to the same container as `list`
+   * const listB = doc.getContainerById(shallowValue.list);
+   * ```
    */
-  shallowSinceFrontiers(): { peer: PeerID, counter: number }[];
+  getShallowValue(): Record<string, ContainerID>;
   /**
-   * Get the version vector of the latest known version in OpLog.
+   * Checkout the `DocState` to the latest version of `OpLog`.
    *
-   * If you checkout to a specific version, this version vector will not change.
-   */
-  oplogVersion(): VersionVector;
-  /**
-   * Get the [frontiers](https://loro.dev/docs/advanced/version_deep_dive) of the current document state.
+   * > The document becomes detached during a `checkout` operation.
+   * > Being `detached` implies that the `DocState` is not synchronized with the latest version of the `OpLog`.
+   * > In a detached state, the document is not editable by default, and any `import` operations will be
+   * > recorded in the `OpLog` without being applied to the `DocState`.
    *
-   * If you checkout to a specific version, this value will change.
-   */
-  frontiers(): { peer: PeerID, counter: number }[];
-  /**
-   * Get the [frontiers](https://loro.dev/docs/advanced/version_deep_dive) of the latest version in OpLog.
+   * This has the same effect as `attach`.
    *
-   * If you checkout to a specific version, this value will not change.
+   * @example
+   * ```ts
+   * import { LoroDoc } from "loro-crdt";
+   *
+   * const doc = new LoroDoc();
+   * const text = doc.getText("text");
+   * const frontiers = doc.frontiers();
+   * text.insert(0, "Hello World!");
+   * doc.checkout(frontiers);
+   * // you need call `checkoutToLatest()` or `attach()` before changing the doc.
+   * doc.checkoutToLatest();
+   * text.insert(0, "Hi");
+   * ```
    */
-  oplogFrontiers(): { peer: PeerID, counter: number }[];
+  checkoutToLatest(): void;
   /**
    * Compare the version of the OpLog with the specified frontiers.
    *
@@ -2165,235 +2052,267 @@ export class LoroDoc {
    */
   cmpWithFrontiers(frontiers: ({ peer: PeerID, counter: number })[]): number;
   /**
-   * Compare the ordering of two Frontiers.
+   * Delete all content from a root container and hide it from the document.
    *
-   * It's assumed that both Frontiers are included by the doc. Otherwise, an error will be thrown.
+   * When a root container is empty and hidden:
+   * - It won't show up in `get_deep_value()` results
+   * - It won't be included in document snapshots
    *
-   * Return value:
+   * Only works on root containers (containers without parents).
+   */
+  deleteRootContainer(cid: ContainerID): void;
+  /**
+   * Get the number of operations in the pending transaction.
    *
-   * - -1: a < b
-   * - 0: a == b
-   * - 1: a > b
-   * - undefined: a ∥ b: a and b are concurrent
+   * The pending transaction is the one that is not committed yet. It will be committed
+   * automatically after calling `doc.commit()`, `doc.export(mode)` or `doc.checkout(version)`.
    */
-  cmpFrontiers(a: ({ peer: PeerID, counter: number })[], b: ({ peer: PeerID, counter: number })[]): -1 | 1 | 0 | undefined;
+  getPendingTxnLength(): number;
   /**
-   * Export the snapshot of current version.
-   * It includes all the history and the document state
+   * Import updates from the JSON format.
    *
-   * @deprecated Use `export({mode: "snapshot"})` instead
+   * only supports backward compatibility but not forward compatibility.
    */
-  exportSnapshot(): Uint8Array;
+  importJsonUpdates(json: string | JsonSchema): ImportStatus;
   /**
-   * Export the document based on the specified ExportMode.
+   * Import a batch of updates and snapshots.
    *
-   * @param mode - The export mode to use. Can be one of:
-   *   - `{ mode: "snapshot" }`: Export a full snapshot of the document.
-   *   - `{ mode: "update", from?: VersionVector }`: Export updates from the given version vector.
-   *     If `from` is not provided, it will export the whole history of the document.
-   *   - `{ mode: "updates-in-range", spans: { id: ID, len: number }[] }`: Export updates within the specified ID spans.
-   *   - `{ mode: "shallow-snapshot", frontiers: Frontiers }`: Export a garbage-collected snapshot up to the given frontiers.
+   * It's more efficient than importing updates one by one.
    *
-   * @returns A byte array containing the exported data.
+   * @deprecated Use `importBatch` instead.
    *
    * @example
    * ```ts
-   * import { LoroDoc, LoroText } from "loro-crdt";
+   * import { LoroDoc } from "loro-crdt";
    *
    * const doc = new LoroDoc();
-   * doc.setPeerId("1");
-   * doc.getText("text").update("Hello World");
-   *
-   * // Export a full snapshot
-   * const snapshotBytes = doc.export({ mode: "snapshot" });
-   *
-   * // Export updates from a specific version
-   * const vv = doc.oplogVersion();
-   * doc.getText("text").update("Hello Loro");
-   * const updateBytes = doc.export({ mode: "update", from: vv });
-   *
-   * // Export a shallow snapshot that only includes the history since the frontiers
-   * const shallowBytes = doc.export({ mode: "shallow-snapshot", frontiers: doc.oplogFrontiers() });
-   *
-   * // Export updates within specific ID spans
-   * const spanBytes = doc.export({
-   *   mode: "updates-in-range",
-   *   spans: [{ id: { peer: "1", counter: 0 }, len: 10 }]
-   * });
+   * const text = doc.getText("text");
+   * text.insert(0, "Hello");
+   * const updates = doc.export({ mode: "update" });
+   * const snapshot = doc.export({ mode: "snapshot" });
+   * const doc2 = new LoroDoc();
+   * doc2.importBatch([snapshot, updates]);
    * ```
    */
-  export(mode: ExportMode): Uint8Array;
+  importUpdateBatch(data: Uint8Array[]): ImportStatus;
   /**
-   * Import updates from the JSON format.
+   * Enables editing in detached mode, which is disabled by default.
    *
-   * only supports backward compatibility but not forward compatibility.
+   * The doc enter detached mode after calling `detach` or checking out a non-latest version.
+   *
+   * # Important Notes:
+   *
+   * - This mode uses a different PeerID for each checkout.
+   * - Ensure no concurrent operations share the same PeerID if set manually.
+   * - Importing does not affect the document's state or version; changes are
+   *   recorded in the [OpLog] only. Call `checkout` to apply changes.
    */
-  importJsonUpdates(json: string | JsonSchema): ImportStatus;
+  setDetachedEditing(enable: boolean): void;
   /**
-   * Import snapshot or updates into current doc.
+   * Set whether to record the timestamp of each change. Default is `false`.
    *
-   * Note:
-   * - Updates within the current version will be ignored
-   * - Updates with missing dependencies will be pending until the dependencies are received
+   * If enabled, the Unix timestamp (in seconds) will be recorded for each change automatically.
    *
-   * @example
-   * ```ts
-   * import { LoroDoc } from "loro-crdt";
+   * You can also set each timestamp manually when you commit a change.
+   * The timestamp manually set will override the automatic one.
    *
-   * const doc = new LoroDoc();
-   * const text = doc.getText("text");
-   * text.insert(0, "Hello");
-   * // get all updates of the doc
-   * const updates = doc.export({ mode: "update" });
-   * const snapshot = doc.export({ mode: "snapshot" });
-   * const doc2 = new LoroDoc();
-   * // import snapshot
-   * doc2.import(snapshot);
-   * // or import updates
-   * doc2.import(updates);
-   * ```
+   * NOTE: Timestamps are forced to be in ascending order in the OpLog's history.
+   * If you commit a new change with a timestamp that is less than the existing one,
+   * the largest existing timestamp will be used instead.
    */
-  import(update_or_snapshot: Uint8Array): ImportStatus;
+  setRecordTimestamp(auto_record: boolean): void;
   /**
-   * Import a batch of updates and snapshots.
+   * Find the op id spans that between the `from` version and the `to` version.
    *
-   * It's more efficient than importing updates one by one.
+   * You can combine it with `exportJsonInIdSpan` to get the changes between two versions.
    *
-   * @deprecated Use `importBatch` instead.
+   * 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 doc = new LoroDoc();
-   * const text = doc.getText("text");
-   * text.insert(0, "Hello");
-   * const updates = doc.export({ mode: "update" });
-   * const snapshot = doc.export({ mode: "snapshot" });
-   * const doc2 = new LoroDoc();
-   * doc2.importBatch([snapshot, updates]);
+   * 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);
    * ```
    */
-  importUpdateBatch(data: Uint8Array[]): ImportStatus;
+  findIdSpansBetween(from: ({ peer: PeerID, counter: number })[], to: ({ peer: PeerID, counter: number })[]): VersionVectorDiff;
   /**
-   * Import a batch of updates or snapshots.
+   * Get the change of with specific peer_id and lamport <= given lamport
+   */
+  getChangeAtLamport(peer_id: string, lamport: number): Change | undefined;
+  /**
+   * Get the path from the root to the container
+   */
+  getPathToContainer(id: ContainerID): (string|number)[] | undefined;
+  /**
+   * Gets container IDs modified in the given ID range.
    *
-   * It's more efficient than importing updates one by one.
+   * **NOTE:** This method will implicitly commit.
    *
-   * @example
-   * ```ts
-   * import { LoroDoc } from "loro-crdt";
+   * This method identifies which containers were affected by changes in a given range of operations.
+   * It can be used together with `doc.travelChangeAncestors()` to analyze the history of changes
+   * and determine which containers were modified by each change.
    *
-   * const doc = new LoroDoc();
-   * const text = doc.getText("text");
-   * text.insert(0, "Hello");
-   * const updates = doc.export({ mode: "update" });
-   * const snapshot = doc.export({ mode: "snapshot" });
-   * const doc2 = new LoroDoc();
-   * doc2.importBatch([snapshot, updates]);
-   * ```
+   * @param id - The starting ID of the change range
+   * @param len - The length of the change range to check
+   * @returns An array of container IDs that were modified in the given range
    */
-  importBatch(data: Uint8Array[]): ImportStatus;
+  getChangedContainersIn(id: { peer: PeerID, counter: number }, len: number): ContainerID[];
   /**
-   * Get the shallow json format of the document state.
+   * Get deep value of the document with container id
+   */
+  getDeepValueWithID(): any;
+  /**
+   * Set the origin of the next commit
+   */
+  setNextCommitOrigin(origin: string): void;
+  /**
+   * Get the pending operations from the current transaction in JSON format
    *
-   * Unlike `toJSON()` which recursively resolves all containers to their values,
-   * `getShallowValue()` returns container IDs as strings for any nested containers.
+   * This method returns a JSON representation of operations that have been applied
+   * but not yet committed in the current transaction.
+   *
+   * It will use the same data format as `doc.exportJsonUpdates()`
    *
    * @example
    * ```ts
-   * import { LoroDoc } from "loro-crdt";
-   *
    * const doc = new LoroDoc();
-   * const list = doc.getList("list");
-   * const tree = doc.getTree("tree");
-   * const map = doc.getMap("map");
-   * const shallowValue = doc.getShallowValue();
-   * console.log(shallowValue);
-   * // {
-   * //   list: 'cid:root-list:List',
-   * //   tree: 'cid:root-tree:Tree',
-   * //   map: 'cid:root-map:Map'
-   * // }
-   *
-   * // It points to the same container as `list`
-   * const listB = doc.getContainerById(shallowValue.list);
+   * const text = doc.getText("text");
+   * text.insert(0, "Hello");
+   * // Get pending ops before commit
+   * const pendingOps = doc.getPendingOpsFromCurrentTxnAsJson();
+   * doc.commit();
+   * const emptyOps = doc.getPendingOpsFromCurrentTxnAsJson(); // this is undefined
    * ```
    */
-  getShallowValue(): Record<string, ContainerID>;
+  getUncommittedOpsAsJson(): JsonSchema | undefined;
   /**
-   * Get the json format of the entire document state.
-   *
-   * Unlike `getShallowValue()` which returns container IDs as strings,
-   * `toJSON()` recursively resolves all containers to their actual values.
+   * Set the commit message of the next commit
+   */
+  setNextCommitMessage(msg: string): void;
+  /**
+   * Set the options of the next commit
+   */
+  setNextCommitOptions(options: { origin?: string, timestamp?: number, message?: string }): void;
+  /**
+   * The doc only contains the history since this version
    *
-   * @example
-   * ```ts
-   * import { LoroDoc, LoroText, LoroMap } from "loro-crdt";
+   * This is empty if the doc is not shallow.
    *
-   * const doc = new LoroDoc();
-   * const list = doc.getList("list");
-   * list.insert(0, "Hello");
-   * const text = list.insertContainer(0, new LoroText());
-   * text.insert(0, "Hello");
-   * const map = list.insertContainer(1, new LoroMap());
-   * map.set("foo", "bar");
-   * console.log(doc.toJSON());
-   * // {"list": ["Hello", {"foo": "bar"}]}
-   * ```
+   * The ops included by the shallow history start frontiers are not in the doc.
    */
-  toJSON(): any;
+  shallowSinceFrontiers(): { peer: PeerID, counter: number }[];
   /**
-   * Debug the size of the history
+   * Visit all the ancestors of the changes in causal order.
+   *
+   * @param ids - the changes to visit
+   * @param f - the callback function, return `true` to continue visiting, return `false` to stop
    */
-  debugHistory(): void;
+  travelChangeAncestors(ids: ({ peer: PeerID, counter: number })[], f: (change: Change) => boolean): void;
   /**
-   * Get the number of changes in the oplog.
+   * Clear the options of the next commit
    */
-  changeCount(): number;
+  clearNextCommitOptions(): void;
   /**
-   * Get the number of ops in the oplog.
+   * Configures the default text style for the document.
+   *
+   * This method sets the default text style configuration for the document when using LoroText.
+   * If `None` is provided, the default style is reset.
    */
-  opCount(): number;
+  configDefaultTextStyle(style: { expand: 'before'|'after'|'none'|'both' } | undefined): void;
   /**
-   * Get all of changes in the oplog.
+   * If two continuous local changes are within (<=) the interval(**in seconds**), they will be merged into one change.
    *
-   * Note: this method is expensive when the oplog is large. O(n)
+   * 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
+   */
+  setChangeMergeInterval(interval: number): void;
+  /**
+   * Set the timestamp of the next commit
+   */
+  setNextCommitTimestamp(timestamp: number): void;
+  /**
+   * Set whether to hide empty root containers.
    *
    * @example
    * ```ts
-   * import { LoroDoc, LoroText } from "loro-crdt";
-   *
    * const doc = new LoroDoc();
-   * const text = doc.getText("text");
-   * text.insert(0, "Hello");
-   * const changes = doc.getAllChanges();
-   *
-   * for (let [peer, c] of changes.entries()){
-   *     console.log("peer: ", peer);
-   *     for (let change of c){
-   *         console.log("change: ", change);
-   *     }
-   * }
+   * const map = doc.getMap("map");
+   * console.log(doc.toJSON()); // { map: {} }
+   * doc.setHideEmptyRootContainers(true);
+   * console.log(doc.toJSON()); // {}
    * ```
    */
-  getAllChanges(): Map<PeerID, Change[]>;
+  setHideEmptyRootContainers(hide: boolean): void;
   /**
-   * Get the change that contains the specific ID
+   * Whether the editing is enabled in detached mode.
+   *
+   * The doc enter detached mode after calling `detach` or checking out a non-latest version.
+   *
+   * # Important Notes:
+   *
+   * - This mode uses a different PeerID for each checkout.
+   * - Ensure no concurrent operations share the same PeerID if set manually.
+   * - Importing does not affect the document's state or version; changes are
+   *   recorded in the [OpLog] only. Call `checkout` to apply changes.
    */
-  getChangeAt(id: { peer: PeerID, counter: number }): Change;
+  isDetachedEditingEnabled(): boolean;
   /**
-   * Get the change of with specific peer_id and lamport <= given lamport
+   * Create a new loro document.
+   *
+   * New document will have a random peer id.
    */
-  getChangeAtLamport(peer_id: string, lamport: number): Change | undefined;
+  constructor();
   /**
-   * Get all ops of the change that contains the specific ID
+   * Duplicate the document with a different PeerID
+   *
+   * The time complexity and space complexity of this operation are both O(n),
+   *
+   * When called in detached mode, it will fork at the current state frontiers.
+   * It will have the same effect as `forkAt(&self.frontiers())`.
    */
-  getOpsInChange(id: { peer: PeerID, counter: number }): any[];
+  fork(): LoroDoc;
   /**
-   * Convert frontiers to a version vector
+   * Attach the document state to the latest known version.
    *
-   * Learn more about frontiers and version vector [here](https://loro.dev/docs/advanced/version_deep_dive)
+   * > The document becomes detached during a `checkout` operation.
+   * > Being `detached` implies that the `DocState` is not synchronized with the latest version of the `OpLog`.
+   * > In a detached state, the document is not editable, and any `import` operations will be
+   * > recorded in the `OpLog` without being applied to the `DocState`.
+   *
+   * This method has the same effect as invoking `checkoutToLatest`.
    *
    * @example
    * ```ts
@@ -2401,189 +2320,242 @@ export class LoroDoc {
    *
    * const doc = new LoroDoc();
    * const text = doc.getText("text");
-   * text.insert(0, "Hello");
    * const frontiers = doc.frontiers();
-   * const version = doc.frontiersToVV(frontiers);
+   * text.insert(0, "Hello World!");
+   * doc.checkout(frontiers);
+   * // you need call `attach()` or `checkoutToLatest()` before changing the doc.
+   * doc.attach();
+   * text.insert(0, "Hi");
    * ```
    */
-  frontiersToVV(frontiers: ({ peer: PeerID, counter: number })[]): VersionVector;
+  attach(): void;
   /**
-   * Convert a version vector to frontiers
+   * 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:
+   *
+   * - `doc.commit()` is called.
+   * - `doc.export(mode)` is called.
+   * - `doc.import(data)` is called.
+   * - `doc.checkout(version)` is called.
+   *
+   * NOTE: Timestamps are forced to be in ascending order.
+   * If you commit a new change with a timestamp that is less than the existing one,
+   * the largest existing timestamp will be used instead.
+   *
+   * NOTE: The `origin` will not be persisted, but the `message` will.
+   *
+   * Behavior on empty commits:
+   * - This method is an explicit commit. If the pending transaction is empty, any provided
+   *   options (message/timestamp/origin) are swallowed and will not carry over to the next commit.
+   * - Implicit commits triggered by `export`/`checkout` act as processing barriers. If the
+   *   transaction is empty in those cases, `message`/`timestamp`/`origin` are preserved for the
+   *   next commit.
+   */
+  commit(options?: { origin?: string, timestamp?: number, message?: string } | null): void;
+  /**
+   * Detach the document state from the latest known version.
+   *
+   * After detaching, all import operations will be recorded in the `OpLog` without being applied to the `DocState`.
+   * When `detached`, the document is not editable.
    *
    * @example
    * ```ts
    * import { LoroDoc } from "loro-crdt";
    *
    * const doc = new LoroDoc();
-   * const text = doc.getText("text");
-   * text.insert(0, "Hello");
-   * const version = doc.version();
-   * const frontiers = doc.vvToFrontiers(version);
+   * doc.detach();
+   * console.log(doc.isDetached());  // true
    * ```
    */
-  vvToFrontiers(vv: VersionVector): { peer: PeerID, counter: number }[];
+  detach(): void;
   /**
-   * Get the value or container at the given path
-   *
-   * The path can be specified in different ways depending on the container type:
-   *
-   * For Tree:
-   * 1. Using node IDs: `tree/{node_id}/property`
-   * 2. Using indices: `tree/0/1/property`
-   *
-   * For List and MovableList:
-   * - Using indices: `list/0` or `list/1/property`
+   * Export the document based on the specified ExportMode.
    *
-   * For Map:
-   * - Using keys: `map/key` or `map/nested/property`
+   * @param mode - The export mode to use. Can be one of:
+   *   - `{ mode: "snapshot" }`: Export a full snapshot of the document.
+   *   - `{ mode: "update", from?: VersionVector }`: Export updates from the given version vector.
+   *     If `from` is not provided, it will export the whole history of the document.
+   *   - `{ mode: "updates-in-range", spans: { id: ID, len: number }[] }`: Export updates within the specified ID spans.
+   *   - `{ mode: "shallow-snapshot", frontiers: Frontiers }`: Export a garbage-collected snapshot up to the given frontiers.
    *
-   * For tree structures, index-based paths follow depth-first traversal order.
-   * The indices start from 0 and represent the position of a node among its siblings.
+   * @returns A byte array containing the exported data.
    *
    * @example
    * ```ts
-   * import { LoroDoc } from "loro-crdt";
+   * import { LoroDoc, LoroText } from "loro-crdt";
    *
    * const doc = new LoroDoc();
-   * const map = doc.getMap("map");
-   * map.set("key", 1);
-   * console.log(doc.getByPath("map/key")); // 1
-   * console.log(doc.getByPath("map"));     // LoroMap
+   * doc.setPeerId("1");
+   * doc.getText("text").update("Hello World");
+   *
+   * // Export a full snapshot
+   * const snapshotBytes = doc.export({ mode: "snapshot" });
+   *
+   * // Export updates from a specific version
+   * const vv = doc.oplogVersion();
+   * doc.getText("text").update("Hello Loro");
+   * const updateBytes = doc.export({ mode: "update", from: vv });
+   *
+   * // Export a shallow snapshot that only includes the history since the frontiers
+   * const shallowBytes = doc.export({ mode: "shallow-snapshot", frontiers: doc.oplogFrontiers() });
+   *
+   * // Export updates within specific ID spans
+   * const spanBytes = doc.export({
+   *   mode: "updates-in-range",
+   *   spans: [{ id: { peer: "1", counter: 0 }, len: 10 }]
+   * });
    * ```
    */
-  getByPath(path: string): Value | Container | undefined;
+  export(mode: ExportMode): Uint8Array;
   /**
-   * Get the absolute position of the given Cursor
+   * Import snapshot or updates into current doc.
+   *
+   * Note:
+   * - Updates within the current version will be ignored
+   * - Updates with missing dependencies will be pending until the dependencies are received
    *
    * @example
    * ```ts
+   * import { LoroDoc } from "loro-crdt";
+   *
    * const doc = new LoroDoc();
    * const text = doc.getText("text");
-   * text.insert(0, "123");
-   * const pos0 = text.getCursor(0, 0);
-   * {
-   *    const ans = doc.getCursorPos(pos0!);
-   *    expect(ans.offset).toBe(0);
-   * }
-   * text.insert(0, "1");
-   * {
-   *    const ans = doc.getCursorPos(pos0!);
-   *    expect(ans.offset).toBe(1);
-   * }
+   * text.insert(0, "Hello");
+   * // get all updates of the doc
+   * const updates = doc.export({ mode: "update" });
+   * const snapshot = doc.export({ mode: "snapshot" });
+   * const doc2 = new LoroDoc();
+   * // import snapshot
+   * doc2.import(snapshot);
+   * // or import updates
+   * doc2.import(updates);
    * ```
    */
-  getCursorPos(cursor: Cursor): { update?: Cursor, offset: number, side: Side } | undefined;
+  import(update_or_snapshot: Uint8Array): ImportStatus;
   /**
-   * Gets container IDs modified in the given ID range.
-   *
-   * **NOTE:** This method will implicitly commit.
-   *
-   * This method identifies which containers were affected by changes in a given range of operations.
-   * It can be used together with `doc.travelChangeAncestors()` to analyze the history of changes
-   * and determine which containers were modified by each change.
+   * Creates a new LoroDoc at a specified version (Frontiers)
    *
-   * @param id - The starting ID of the change range
-   * @param len - The length of the change range to check
-   * @returns An array of container IDs that were modified in the given range
+   * The created doc will only contain the history before the specified frontiers.
    */
-  getChangedContainersIn(id: { peer: PeerID, counter: number }, len: number): ContainerID[];
+  forkAt(frontiers: ({ peer: PeerID, counter: number })[]): LoroDoc;
   /**
-   * Revert the document to the given frontiers.
+   * Get the number of ops in the oplog.
+   */
+  opCount(): number;
+  /**
+   * Get the json format of the entire document state.
    *
-   * 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.
+   * Unlike `getShallowValue()` which returns container IDs as strings,
+   * `toJSON()` recursively resolves all containers to their actual values.
    *
    * @example
    * ```ts
+   * import { LoroDoc, LoroText, LoroMap } from "loro-crdt";
+   *
    * const doc = new LoroDoc();
-   * doc.setPeerId("1");
-   * const text = doc.getText("text");
+   * const list = doc.getList("list");
+   * list.insert(0, "Hello");
+   * const text = list.insertContainer(0, new LoroText());
    * text.insert(0, "Hello");
-   * doc.commit();
-   * doc.revertTo([{ peer: "1", counter: 1 }]);
-   * expect(doc.getText("text").toString()).toBe("He");
+   * const map = list.insertContainer(1, new LoroMap());
+   * map.set("foo", "bar");
+   * console.log(doc.toJSON());
+   * // {"list": ["Hello", {"foo": "bar"}]}
    * ```
    */
-  revertTo(frontiers: ({ peer: PeerID, counter: number })[]): void;
+  toJSON(): any;
   /**
-   * Apply a batch of diff to the document
+   * Get the version vector of the current document state.
    *
-   * A diff batch represents a set of changes between two versions of the document.
-   * You can calculate a diff batch using `doc.diff()`.
+   * If you checkout to a specific version, the version vector will change.
+   */
+  version(): VersionVector;
+  /**
+   * Checkout the `DocState` to a specific version.
    *
-   * Changes are associated with container IDs. During diff application, if new containers were created in the source
-   * document, they will be assigned fresh IDs in the target document. Loro automatically handles remapping these
-   * container IDs from their original IDs to the new IDs as the diff is applied.
+   * > The document becomes detached during a `checkout` operation.
+   * > Being `detached` implies that the `DocState` is not synchronized with the latest version of the `OpLog`.
+   * > In a detached state, the document is not editable, and any `import` operations will be
+   * > recorded in the `OpLog` without being applied to the `DocState`.
    *
-   * @example
-   * ```ts
-   * const doc1 = new LoroDoc();
-   * const doc2 = new LoroDoc();
+   * You should call `attach` to attach the `DocState` to the latest version of `OpLog`.
    *
-   * // Make some changes to doc1
-   * const text = doc1.getText("text");
-   * text.insert(0, "Hello");
+   * @param frontiers - the specific frontiers
    *
-   * // Calculate diff between empty and current state
-   * const diff = doc1.diff([], doc1.frontiers());
+   * @example
+   * ```ts
+   * import { LoroDoc } from "loro-crdt";
    *
-   * // Apply changes to doc2
-   * doc2.applyDiff(diff);
-   * console.log(doc2.getText("text").toString()); // "Hello"
+   * const doc = new LoroDoc();
+   * const text = doc.getText("text");
+   * const frontiers = doc.frontiers();
+   * text.insert(0, "Hello World!");
+   * doc.checkout(frontiers);
+   * console.log(doc.toJSON()); // {"text": ""}
    * ```
    */
-  applyDiff(diff: [ContainerID, Diff|JsonDiff][]): void;
+  checkout(frontiers: ({ peer: PeerID, counter: number })[]): void;
   /**
-   * Get the pending operations from the current transaction in JSON format
+   * Get a LoroText by container id.
    *
-   * This method returns a JSON representation of operations that have been applied
-   * but not yet committed in the current transaction.
+   * The object returned is a new js object each time because it need to cross
+   * the WASM boundary.
    *
-   * It will use the same data format as `doc.exportJsonUpdates()`
+   * If the container does not exist, an error will be thrown.
    *
    * @example
    * ```ts
+   * import { LoroDoc } from "loro-crdt";
+   *
    * const doc = new LoroDoc();
    * const text = doc.getText("text");
-   * text.insert(0, "Hello");
-   * // Get pending ops before commit
-   * const pendingOps = doc.getPendingOpsFromCurrentTxnAsJson();
-   * doc.commit();
-   * const emptyOps = doc.getPendingOpsFromCurrentTxnAsJson(); // this is undefined
    * ```
    */
-  getUncommittedOpsAsJson(): JsonSchema | undefined;
+  getText(cid: ContainerID | string): LoroText;
   /**
-   * Delete all content from a root container and hide it from the document.
-   *
-   * When a root container is empty and hidden:
-   * - It won't show up in `get_deep_value()` results
-   * - It won't be included in document snapshots
+   * Get the [frontiers](https://loro.dev/docs/advanced/version_deep_dive) of the current document state.
    *
-   * Only works on root containers (containers without parents).
+   * If you checkout to a specific version, this value will change.
    */
-  deleteRootContainer(cid: ContainerID): void;
+  frontiers(): { peer: PeerID, counter: number }[];
   /**
-   * Set whether to hide empty root containers.
+   * Evaluate JSONPath against a LoroDoc
+   */
+  JSONPath(jsonpath: string): Array<any>;
+  /**
+   * 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();
-   * const map = doc.getMap("map");
-   * console.log(doc.toJSON()); // { map: {} }
-   * doc.setHideEmptyRootContainers(true);
-   * console.log(doc.toJSON()); // {}
+   * 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");
    * ```
    */
-  setHideEmptyRootContainers(hide: boolean): void;
-  /**
-   * Peer ID of the current writer.
-   */
-  readonly peerId: bigint;
+  revertTo(frontiers: ({ peer: PeerID, counter: number })[]): void;
   /**
    * Get peer id in decimal string.
    */
   readonly peerIdStr: PeerID;
+  /**
+   * Peer ID of the current writer.
+   */
+  readonly peerId: bigint;
 }
 /**
  * The handler of a list container.
@@ -2592,6 +2564,37 @@ export class LoroDoc {
  */
 export class LoroList {
   free(): void;
+  /**
+   * Whether the container is attached to a document.
+   *
+   * If it's detached, the operations on the container will not be persisted.
+   */
+  isAttached(): boolean;
+  /**
+   * Get the attached container associated with this.
+   *
+   * Returns an attached `Container` that equals to this or created by this, otherwise `undefined`.
+   */
+  getAttached(): LoroList | undefined;
+  /**
+   * Get the shallow value of the list.
+   *
+   * Unlike `toJSON()` which recursively resolves all containers to their values,
+   * `getShallowValue()` returns container IDs as strings for any nested containers.
+   *
+   * ```js
+   * const doc = new LoroDoc();
+   * doc.setPeerId("1");
+   * const list = doc.getList("list");
+   * list.insert(0, 1);
+   * list.insert(1, "two");
+   * const subList = list.insertContainer(2, new LoroList());
+   * subList.insert(0, "sub");
+   * list.getShallowValue(); // [1, "two", "cid:2@1:List"]
+   * list.toJSON(); // [1, "two", ["sub"]]
+   * ```
+   */
+  getShallowValue(): Value[];
   /**
    * Create a new detached LoroList (not attached to any LoroDoc).
    *
@@ -2599,10 +2602,18 @@ export class LoroList {
    * To attach the container to the document, please insert it into an attached container.
    */
   constructor();
+  /**
+   * Pop a value from the end of the list.
+   */
+  pop(): Value | undefined;
   /**
    * "List"
    */
   kind(): 'List';
+  /**
+   * Delete all elements in the list.
+   */
+  clear(): void;
   /**
    * Delete elements from index to index + len.
    *
@@ -2618,6 +2629,15 @@ export class LoroList {
    * ```
    */
   delete(index: number, len: number): void;
+  /**
+   * Get the parent container.
+   *
+   * - The parent container of the root tree is `undefined`.
+   * - The object returned is a new js object each time because it need to cross
+   *   the WASM boundary.
+   */
+  parent(): Container | undefined;
+  getIdAt(pos: number): { peer: PeerID, counter: number } | undefined;
   /**
    * Get elements of the list. If the type of a element is a container, it will be
    * resolved recursively.
@@ -2635,58 +2655,10 @@ export class LoroList {
    * ```
    */
   toJSON(): any;
-  /**
-   * Get the parent container.
-   *
-   * - The parent container of the root tree is `undefined`.
-   * - The object returned is a new js object each time because it need to cross
-   *   the WASM boundary.
-   */
-  parent(): Container | undefined;
-  /**
-   * Whether the container is attached to a document.
-   *
-   * If it's detached, the operations on the container will not be persisted.
-   */
-  isAttached(): boolean;
-  /**
-   * Get the attached container associated with this.
-   *
-   * Returns an attached `Container` that equals to this or created by this, otherwise `undefined`.
-   */
-  getAttached(): LoroList | undefined;
-  /**
-   * Pop a value from the end of the list.
-   */
-  pop(): Value | undefined;
-  /**
-   * Delete all elements in the list.
-   */
-  clear(): void;
-  getIdAt(pos: number): { peer: PeerID, counter: number } | undefined;
   /**
    * Check if the container is deleted
    */
   isDeleted(): boolean;
-  /**
-   * Get the shallow value of the list.
-   *
-   * Unlike `toJSON()` which recursively resolves all containers to their values,
-   * `getShallowValue()` returns container IDs as strings for any nested containers.
-   *
-   * ```js
-   * const doc = new LoroDoc();
-   * doc.setPeerId("1");
-   * const list = doc.getList("list");
-   * list.insert(0, 1);
-   * list.insert(1, "two");
-   * const subList = list.insertContainer(2, new LoroList());
-   * subList.insert(0, "sub");
-   * list.getShallowValue(); // [1, "two", "cid:2@1:List"]
-   * list.toJSON(); // [1, "two", ["sub"]]
-   * ```
-   */
-  getShallowValue(): Value[];
   /**
    * Get the id of this container.
    */
@@ -2716,30 +2688,55 @@ export class LoroList {
 export class LoroMap {
   free(): void;
   /**
-   * Create a new detached LoroMap (not attached to any LoroDoc).
+   * Whether the container is attached to a document.
    *
-   * The edits on a detached container will not be persisted.
-   * To attach the container to the document, please insert it into an attached container.
+   * If it's detached, the operations on the container will not be persisted.
    */
-  constructor();
+  isAttached(): boolean;
   /**
-   * "Map"
+   * Get the attached container associated with this.
+   *
+   * Returns an attached `Container` that equals to this or created by this, otherwise `undefined`.
    */
-  kind(): 'Map';
+  getAttached(): LoroMap | undefined;
   /**
-   * Remove the key from the map.
+   * Get the peer id of the last editor on the given entry
+   */
+  getLastEditor(key: string): PeerID | undefined;
+  /**
+   * Get the shallow value of the map.
+   *
+   * Unlike `toJSON()` which recursively resolves all containers to their values,
+   * `getShallowValue()` returns container IDs as strings for any nested containers.
    *
    * @example
    * ```ts
-   * import { LoroDoc } from "loro-crdt";
+   * import { LoroDoc, LoroText } from "loro-crdt";
    *
    * const doc = new LoroDoc();
+   * doc.setPeerId("1");
    * const map = doc.getMap("map");
-   * map.set("foo", "bar");
-   * map.delete("foo");
+   * map.set("key", "value");
+   * const subText = map.setContainer("text", new LoroText());
+   * subText.insert(0, "Hello");
+   *
+   * // Get shallow value - nested containers are represented by their IDs
+   * console.log(map.getShallowValue());
+   * // Output: { key: "value", text: "cid:1@1:Text" }
+   *
+   * // Get full value with nested containers resolved by `toJSON()`
+   * console.log(map.toJSON());
+   * // Output: { key: "value", text: "Hello" }
    * ```
    */
-  delete(key: string): void;
+  getShallowValue(): Record<string, Value>;
+  /**
+   * Create a new detached LoroMap (not attached to any LoroDoc).
+   *
+   * The edits on a detached container will not be persisted.
+   * To attach the container to the document, please insert it into an attached container.
+   */
+  constructor();
   /**
    * Get the keys of the map.
    *
@@ -2755,6 +2752,36 @@ export class LoroMap {
    * ```
    */
   keys(): any[];
+  /**
+   * "Map"
+   */
+  kind(): 'Map';
+  /**
+   * Delete all key-value pairs in the map.
+   */
+  clear(): void;
+  /**
+   * Remove the key from the map.
+   *
+   * @example
+   * ```ts
+   * import { LoroDoc } from "loro-crdt";
+   *
+   * const doc = new LoroDoc();
+   * const map = doc.getMap("map");
+   * map.set("foo", "bar");
+   * map.delete("foo");
+   * ```
+   */
+  delete(key: string): void;
+  /**
+   * Get the parent container.
+   *
+   * - The parent container of the root tree is `undefined`.
+   * - The object returned is a new js object each time because it need to cross
+   *   the WASM boundary.
+   */
+  parent(): Container | undefined;
   /**
    * Get the values of the map. If the value is a child container, the corresponding
    * `Container` will be returned.
@@ -2803,66 +2830,11 @@ export class LoroMap {
    * console.log(map.toJSON());  // {"foo": "bar", "text": "Hello"}
    * ```
    */
-  toJSON(): any;
-  /**
-   * Get the parent container.
-   *
-   * - The parent container of the root tree is `undefined`.
-   * - The object returned is a new js object each time because it need to cross
-   *   the WASM boundary.
-   */
-  parent(): Container | undefined;
-  /**
-   * Whether the container is attached to a document.
-   *
-   * If it's detached, the operations on the container will not be persisted.
-   */
-  isAttached(): boolean;
-  /**
-   * Get the attached container associated with this.
-   *
-   * Returns an attached `Container` that equals to this or created by this, otherwise `undefined`.
-   */
-  getAttached(): LoroMap | undefined;
-  /**
-   * Delete all key-value pairs in the map.
-   */
-  clear(): void;
-  /**
-   * Get the peer id of the last editor on the given entry
-   */
-  getLastEditor(key: string): PeerID | undefined;
-  /**
-   * Check if the container is deleted
-   */
-  isDeleted(): boolean;
-  /**
-   * Get the shallow value of the map.
-   *
-   * Unlike `toJSON()` which recursively resolves all containers to their values,
-   * `getShallowValue()` returns container IDs as strings for any nested containers.
-   *
-   * @example
-   * ```ts
-   * import { LoroDoc, LoroText } from "loro-crdt";
-   *
-   * const doc = new LoroDoc();
-   * doc.setPeerId("1");
-   * const map = doc.getMap("map");
-   * map.set("key", "value");
-   * const subText = map.setContainer("text", new LoroText());
-   * subText.insert(0, "Hello");
-   *
-   * // Get shallow value - nested containers are represented by their IDs
-   * console.log(map.getShallowValue());
-   * // Output: { key: "value", text: "cid:1@1:Text" }
-   *
-   * // Get full value with nested containers resolved by `toJSON()`
-   * console.log(map.toJSON());
-   * // Output: { key: "value", text: "Hello" }
-   * ```
-   */
-  getShallowValue(): Record<string, Value>;
+  toJSON(): any;
+  /**
+   * Check if the container is deleted
+   */
+  isDeleted(): boolean;
   /**
    * The container id of this handler.
    */
@@ -2890,68 +2862,48 @@ export class LoroMap {
 export class LoroMovableList {
   free(): void;
   /**
-   * Create a new detached LoroMovableList (not attached to any LoroDoc).
+   * Whether the container is attached to a document.
    *
-   * The edits on a detached container will not be persisted.
-   * To attach the container to the document, please insert it into an attached container.
+   * If it's detached, the operations on the container will not be persisted.
    */
-  constructor();
+  isAttached(): boolean;
   /**
-   * "MovableList"
+   * Get the creator of the list item at the given position.
    */
-  kind(): 'MovableList';
+  getCreatorAt(pos: number): PeerID | undefined;
   /**
-   * Delete elements from index to index + len.
-   *
-   * @example
-   * ```ts
-   * import { LoroDoc } from "loro-crdt";
+   * Get the attached container associated with this.
    *
-   * const doc = new LoroDoc();
-   * const list = doc.getList("list");
-   * list.insert(0, 100);
-   * list.delete(0, 1);
-   * console.log(list.value);  // []
-   * ```
+   * Returns an attached `Container` that equals to this or created by this, otherwise `undefined`.
    */
-  delete(index: number, len: number): void;
+  getAttached(): LoroList | undefined;
   /**
-   * Get elements of the list. If the type of a element is a container, it will be
-   * resolved recursively.
-   *
-   * @example
-   * ```ts
-   * import { LoroDoc, LoroText } from "loro-crdt";
-   *
-   * const doc = new LoroDoc();
-   * const list = doc.getList("list");
-   * list.insert(0, 100);
-   * const text = list.insertContainer(1, new LoroText());
-   * text.insert(0, "Hello");
-   * console.log(list.toJSON());  // [100, "Hello"];
-   * ```
+   * Get the last mover of the list item at the given position.
    */
-  toJSON(): any;
+  getLastMoverAt(pos: number): PeerID | undefined;
   /**
-   * Get the parent container.
-   *
-   * - The parent container of the root tree is `undefined`.
-   * - The object returned is a new js object each time because it need to cross
-   *   the WASM boundary.
+   * Get the last editor of the list item at the given position.
    */
-  parent(): Container | undefined;
+  getLastEditorAt(pos: number): PeerID | undefined;
   /**
-   * Whether the container is attached to a document.
+   * Get the shallow value of the movable list.
    *
-   * If it's detached, the operations on the container will not be persisted.
-   */
-  isAttached(): boolean;
-  /**
-   * Get the attached container associated with this.
+   * Unlike `toJSON()` which recursively resolves all containers to their values,
+   * `getShallowValue()` returns container IDs as strings for any nested containers.
    *
-   * Returns an attached `Container` that equals to this or created by this, otherwise `undefined`.
+   * ```js
+   * const doc = new LoroDoc();
+   * doc.setPeerId("1");
+   * const list = doc.getMovableList("list");
+   * list.insert(0, 1);
+   * list.insert(1, "two");
+   * const subList = list.insertContainer(2, new LoroList());
+   * subList.insert(0, "sub");
+   * list.getShallowValue(); // [1, "two", "cid:2@1:List"]
+   * list.toJSON(); // [1, "two", ["sub"]]
+   * ```
    */
-  getAttached(): LoroList | undefined;
+  getShallowValue(): Value[];
   /**
    * Move the element from `from` to `to`.
    *
@@ -2966,48 +2918,68 @@ export class LoroMovableList {
    */
   move(from: number, to: number): void;
   /**
-   * Pop a value from the end of the list.
+   * Create a new detached LoroMovableList (not attached to any LoroDoc).
+   *
+   * The edits on a detached container will not be persisted.
+   * To attach the container to the document, please insert it into an attached container.
    */
-  pop(): Value | undefined;
+  constructor();
   /**
-   * Delete all elements in the list.
+   * Pop a value from the end of the list.
    */
-  clear(): void;
+  pop(): Value | undefined;
   /**
-   * Get the creator of the list item at the given position.
+   * "MovableList"
    */
-  getCreatorAt(pos: number): PeerID | undefined;
+  kind(): 'MovableList';
   /**
-   * Get the last mover of the list item at the given position.
+   * Delete all elements in the list.
    */
-  getLastMoverAt(pos: number): PeerID | undefined;
+  clear(): void;
   /**
-   * Get the last editor of the list item at the given position.
+   * Delete elements from index to index + len.
+   *
+   * @example
+   * ```ts
+   * import { LoroDoc } from "loro-crdt";
+   *
+   * const doc = new LoroDoc();
+   * const list = doc.getList("list");
+   * list.insert(0, 100);
+   * list.delete(0, 1);
+   * console.log(list.value);  // []
+   * ```
    */
-  getLastEditorAt(pos: number): PeerID | undefined;
+  delete(index: number, len: number): void;
   /**
-   * Check if the container is deleted
+   * Get the parent container.
+   *
+   * - The parent container of the root tree is `undefined`.
+   * - The object returned is a new js object each time because it need to cross
+   *   the WASM boundary.
    */
-  isDeleted(): boolean;
+  parent(): Container | undefined;
   /**
-   * Get the shallow value of the movable list.
+   * Get elements of the list. If the type of a element is a container, it will be
+   * resolved recursively.
    *
-   * Unlike `toJSON()` which recursively resolves all containers to their values,
-   * `getShallowValue()` returns container IDs as strings for any nested containers.
+   * @example
+   * ```ts
+   * import { LoroDoc, LoroText } from "loro-crdt";
    *
-   * ```js
    * const doc = new LoroDoc();
-   * doc.setPeerId("1");
-   * const list = doc.getMovableList("list");
-   * list.insert(0, 1);
-   * list.insert(1, "two");
-   * const subList = list.insertContainer(2, new LoroList());
-   * subList.insert(0, "sub");
-   * list.getShallowValue(); // [1, "two", "cid:2@1:List"]
-   * list.toJSON(); // [1, "two", ["sub"]]
+   * const list = doc.getList("list");
+   * list.insert(0, 100);
+   * const text = list.insertContainer(1, new LoroText());
+   * text.insert(0, "Hello");
+   * console.log(list.toJSON());  // [100, "Hello"];
    * ```
    */
-  getShallowValue(): Value[];
+  toJSON(): any;
+  /**
+   * Check if the container is deleted
+   */
+  isDeleted(): boolean;
   /**
    * Get the id of this container.
    */
@@ -3037,38 +3009,34 @@ export class LoroMovableList {
 export class LoroText {
   free(): void;
   /**
-   * Create a new detached LoroText (not attached to any LoroDoc).
-   *
-   * The edits on a detached container will not be persisted.
-   * To attach the container to the document, please insert it into an attached container.
-   */
-  constructor();
-  /**
-   * "Text"
-   */
-  kind(): 'Text';
-  /**
-   * Iterate each text span(internal storage unit)
+   * Change the state of this text by delta.
    *
-   * The callback function will be called for each span in the text.
-   * If the callback returns `false`, the iteration will stop.
+   * If a delta item is `insert`, it should include all the attributes of the inserted text.
+   * Loro's rich text CRDT may make the inserted text inherit some styles when you use
+   * `insert` method directly. However, when you use `applyDelta` if some attributes are
+   * inherited from CRDT but not included in the delta, they will be removed.
    *
-   * Limitation: you cannot access or alter the doc state when iterating (this is for performance consideration).
-   * If you need to access or alter the doc state, please use `toString` instead.
+   * Another special property of `applyDelta` is if you format an attribute for ranges out of
+   * the text length, Loro will insert new lines to fill the gap first. It's useful when you
+   * build the binding between Loro and rich text editors like Quill, which might assume there
+   * is always a newline at the end of the text implicitly.
    *
    * @example
    * ```ts
-   * import { LoroDoc } from "loro-crdt";
-   *
    * const doc = new LoroDoc();
    * const text = doc.getText("text");
-   * text.insert(0, "Hello");
-   * text.iter((str) => (console.log(str), true));
+   * doc.configTextStyle({bold: {expand: "after"}});
+   * text.insert(0, "Hello World!");
+   * text.mark({ start: 0, end: 5 }, "bold", true);
+   * const delta = text.toDelta();
+   * const text2 = doc.getText("text2");
+   * text2.applyDelta(delta);
+   * expect(text2.toDelta()).toStrictEqual(delta);
    * ```
    */
-  iter(callback: (string) => boolean): void;
+  applyDelta(delta: Delta<string>[]): void;
   /**
-   * Insert the string at the given index (utf-16 index).
+   * Delete elements from index to utf-8 index + len
    *
    * @example
    * ```ts
@@ -3076,12 +3044,19 @@ export class LoroText {
    *
    * const doc = new LoroDoc();
    * const text = doc.getText("text");
-   * text.insert(0, "Hello");
+   * text.insertUtf8(0, "Hello");
+   * text.deleteUtf8(1, 3);
+   * const s = text.toString();
+   * console.log(s); // "Ho"
    * ```
    */
-  insert(index: number, content: string): void;
+  deleteUtf8(index: number, len: number): void;
   /**
-   * Get a string slice (utf-16 index).
+   * Get the editor of the text at the given position.
+   */
+  getEditorOf(pos: number): PeerID | undefined;
+  /**
+   * Insert some string at utf-8 index.
    *
    * @example
    * ```ts
@@ -3089,13 +3064,41 @@ export class LoroText {
    *
    * const doc = new LoroDoc();
    * const text = doc.getText("text");
-   * text.insert(0, "Hello");
-   * text.slice(0, 2); // "He"
+   * text.insertUtf8(0, "Hello");
    * ```
    */
-  slice(start_index: number, end_index: number): string;
+  insertUtf8(index: number, content: string): void;
   /**
-   * Get the character at the given position (utf-16 index).
+   * Whether the container is attached to a LoroDoc.
+   *
+   * If it's detached, the operations on the container will not be persisted.
+   */
+  isAttached(): boolean;
+  /**
+   * Get the attached container associated with this.
+   *
+   * Returns an attached `Container` that is equal to this or created by this; otherwise, it returns `undefined`.
+   */
+  getAttached(): LoroText | undefined;
+  /**
+   * Get the shallow value of the text. This equals to `text.toString()`.
+   */
+  getShallowValue(): string;
+  /**
+   * Create a new detached LoroText (not attached to any LoroDoc).
+   *
+   * The edits on a detached container will not be persisted.
+   * To attach the container to the document, please insert it into an attached container.
+   */
+  constructor();
+  /**
+   * Iterate each text span(internal storage unit)
+   *
+   * The callback function will be called for each span in the text.
+   * If the callback returns `false`, the iteration will stop.
+   *
+   * Limitation: you cannot access or alter the doc state when iterating (this is for performance consideration).
+   * If you need to access or alter the doc state, please use `toString` instead.
    *
    * @example
    * ```ts
@@ -3104,26 +3107,39 @@ export class LoroText {
    * const doc = new LoroDoc();
    * const text = doc.getText("text");
    * text.insert(0, "Hello");
-   * text.charAt(0); // "H"
+   * text.iter((str) => (console.log(str), true));
    * ```
    */
-  charAt(pos: number): string;
+  iter(callback: (string) => boolean): void;
   /**
-   * Delete and return the string at the given range and insert a string at the same position (utf-16 index).
+   * "Text"
+   */
+  kind(): 'Text';
+  /**
+   * Mark a range of text with a key and a value (utf-16 index).
+   *
+   * > You should call `configTextStyle` before using `mark` and `unmark`.
+   *
+   * You can use it to create a highlight, make a range of text bold, or add a link to a range of text.
    *
    * @example
    * ```ts
    * import { LoroDoc } from "loro-crdt";
    *
    * const doc = new LoroDoc();
+   * doc.configTextStyle({bold: {expand: "after"}});
    * const text = doc.getText("text");
-   * text.insert(0, "Hello");
-   * text.splice(2, 3, "llo"); // "llo"
+   * text.insert(0, "Hello World!");
+   * text.mark({ start: 0, end: 5 }, "bold", true);
    * ```
    */
-  splice(pos: number, len: number, s: string): string;
+  mark(range: { start: number, end: number }, key: string, value: any): void;
   /**
-   * Insert some string at utf-8 index.
+   * Push a string to the end of the text.
+   */
+  push(s: string): void;
+  /**
+   * Get a string slice (utf-16 index).
    *
    * @example
    * ```ts
@@ -3131,10 +3147,11 @@ export class LoroText {
    *
    * const doc = new LoroDoc();
    * const text = doc.getText("text");
-   * text.insertUtf8(0, "Hello");
+   * text.insert(0, "Hello");
+   * text.slice(0, 2); // "He"
    * ```
    */
-  insertUtf8(index: number, content: string): void;
+  slice(start_index: number, end_index: number): string;
   /**
    * Delete elements from index to index + len (utf-16 index).
    *
@@ -3152,7 +3169,7 @@ export class LoroText {
    */
   delete(index: number, len: number): void;
   /**
-   * Delete elements from index to utf-8 index + len
+   * Insert the string at the given index (utf-16 index).
    *
    * @example
    * ```ts
@@ -3160,32 +3177,32 @@ export class LoroText {
    *
    * const doc = new LoroDoc();
    * const text = doc.getText("text");
-   * text.insertUtf8(0, "Hello");
-   * text.deleteUtf8(1, 3);
-   * const s = text.toString();
-   * console.log(s); // "Ho"
+   * text.insert(0, "Hello");
    * ```
    */
-  deleteUtf8(index: number, len: number): void;
+  insert(index: number, content: string): void;
   /**
-   * Mark a range of text with a key and a value (utf-16 index).
-   *
-   * > You should call `configTextStyle` before using `mark` and `unmark`.
+   * Get the parent container.
    *
-   * You can use it to create a highlight, make a range of text bold, or add a link to a range of text.
+   * - The parent of the root is `undefined`.
+   * - The object returned is a new js object each time because it need to cross
+   *   the WASM boundary.
+   */
+  parent(): Container | undefined;
+  /**
+   * Delete and return the string at the given range and insert a string at the same position (utf-16 index).
    *
    * @example
    * ```ts
    * import { LoroDoc } from "loro-crdt";
    *
    * const doc = new LoroDoc();
-   * doc.configTextStyle({bold: {expand: "after"}});
    * const text = doc.getText("text");
-   * text.insert(0, "Hello World!");
-   * text.mark({ start: 0, end: 5 }, "bold", true);
+   * text.insert(0, "Hello");
+   * text.splice(2, 3, "llo"); // "llo"
    * ```
    */
-  mark(range: { start: number, end: number }, key: string, value: any): void;
+  splice(pos: number, len: number, s: string): string;
   /**
    * Unmark a range of text with a key and a value (utf-16 index).
    *
@@ -3207,13 +3224,7 @@ export class LoroText {
    */
   unmark(range: { start: number, end: number }, key: string): void;
   /**
-   * Convert the text to a string
-   */
-  toString(): string;
-  /**
-   * Get the text in [Delta](https://quilljs.com/docs/delta/) format.
-   *
-   * The returned value will include the rich text information.
+   * Get the character at the given position (utf-16 index).
    *
    * @example
    * ```ts
@@ -3221,80 +3232,41 @@ export class LoroText {
    *
    * const doc = new LoroDoc();
    * const text = doc.getText("text");
-   * doc.configTextStyle({bold: {expand: "after"}});
-   * text.insert(0, "Hello World!");
-   * text.mark({ start: 0, end: 5 }, "bold", true);
-   * console.log(text.toDelta());  // [ { insert: 'Hello', attributes: { bold: true } } ]
+   * text.insert(0, "Hello");
+   * text.charAt(0); // "H"
    * ```
    */
-  toDelta(): Delta<string>[];
+  charAt(pos: number): string;
   /**
-   * Change the state of this text by delta.
-   *
-   * If a delta item is `insert`, it should include all the attributes of the inserted text.
-   * Loro's rich text CRDT may make the inserted text inherit some styles when you use
-   * `insert` method directly. However, when you use `applyDelta` if some attributes are
-   * inherited from CRDT but not included in the delta, they will be removed.
+   * Get the JSON representation of the text.
+   */
+  toJSON(): any;
+  /**
+   * Get the text in [Delta](https://quilljs.com/docs/delta/) format.
    *
-   * Another special property of `applyDelta` is if you format an attribute for ranges out of
-   * the text length, Loro will insert new lines to fill the gap first. It's useful when you
-   * build the binding between Loro and rich text editors like Quill, which might assume there
-   * is always a newline at the end of the text implicitly.
+   * The returned value will include the rich text information.
    *
    * @example
    * ```ts
+   * import { LoroDoc } from "loro-crdt";
+   *
    * const doc = new LoroDoc();
    * const text = doc.getText("text");
    * doc.configTextStyle({bold: {expand: "after"}});
    * text.insert(0, "Hello World!");
    * text.mark({ start: 0, end: 5 }, "bold", true);
-   * const delta = text.toDelta();
-   * const text2 = doc.getText("text2");
-   * text2.applyDelta(delta);
-   * expect(text2.toDelta()).toStrictEqual(delta);
+   * console.log(text.toDelta());  // [ { insert: 'Hello', attributes: { bold: true } } ]
    * ```
    */
-  applyDelta(delta: Delta<string>[]): void;
-  /**
-   * Get the parent container.
-   *
-   * - The parent of the root is `undefined`.
-   * - The object returned is a new js object each time because it need to cross
-   *   the WASM boundary.
-   */
-  parent(): Container | undefined;
-  /**
-   * Whether the container is attached to a LoroDoc.
-   *
-   * If it's detached, the operations on the container will not be persisted.
-   */
-  isAttached(): boolean;
-  /**
-   * Get the attached container associated with this.
-   *
-   * Returns an attached `Container` that is equal to this or created by this; otherwise, it returns `undefined`.
-   */
-  getAttached(): LoroText | undefined;
-  /**
-   * Push a string to the end of the text.
-   */
-  push(s: string): void;
-  /**
-   * Get the editor of the text at the given position.
-   */
-  getEditorOf(pos: number): PeerID | undefined;
+  toDelta(): Delta<string>[];
   /**
    * Check if the container is deleted
    */
   isDeleted(): boolean;
   /**
-   * Get the shallow value of the text. This equals to `text.toString()`.
-   */
-  getShallowValue(): string;
-  /**
-   * Get the JSON representation of the text.
+   * Convert the text to a string
    */
-  toJSON(): any;
+  toString(): string;
   /**
    * Get the container id of the text.
    */
@@ -3312,61 +3284,90 @@ export class LoroText {
 export class LoroTree {
   free(): void;
   /**
-   * Create a new detached LoroTree (not attached to any LoroDoc).
+   * Whether the container is attached to a document.
    *
-   * The edits on a detached container will not be persisted.
-   * To attach the container to the document, please insert it into an attached container.
+   * If it's detached, the operations on the container will not be persisted.
    */
-  constructor();
+  isAttached(): boolean;
   /**
-   * "Tree"
+   * Get the attached container associated with this.
+   *
+   * Returns an attached `Container` that equals to this or created by this, otherwise `undefined`.
    */
-  kind(): 'Tree';
+  getAttached(): LoroTree | undefined;
   /**
-   * Move the target tree node to be a child of the parent.
-   * It's not allowed that the target is an ancestor of the parent
-   * or the target and the parent are the same node.
+   * Return `None` if the node is not exist, otherwise return `Some(true)` if the node is deleted.
+   */
+  isNodeDeleted(target: TreeID): boolean;
+  /**
+   * Get the shallow value of the tree.
+   *
+   * Unlike `toJSON()` which recursively resolves nested containers to their values,
+   * `getShallowValue()` returns container IDs as strings for any nested containers.
    *
    * @example
    * ```ts
-   * import { LoroDoc } from "loro-crdt";
-   *
    * const doc = new LoroDoc();
+   * doc.setPeerId("1");
    * const tree = doc.getTree("tree");
    * const root = tree.createNode();
-   * const node = root.createNode();
-   * const node2 = node.createNode();
-   * tree.move(node2.id, root.id);
-   * // Error will be thrown if move operation creates a cycle
-   * // tree.move(root.id, node.id);
+   * root.data.set("name", "root");
+   * const text = root.data.setContainer("content", new LoroText());
+   * text.insert(0, "Hello");
+   *
+   * console.log(tree.getShallowValue());
+   * // [{
+   * //   id: "0@1",
+   * //   parent: null,
+   * //   index: 0,
+   * //   fractional_index: "80",
+   * //   meta: "cid:0@1:Map",
+   * //   children: []
+   * // }]
+   *
+   * console.log(tree.toJSON());
+   * // [{
+   * //   id: "0@1",
+   * //   parent: null,
+   * //   index: 0,
+   * //   fractional_index: "80",
+   * //   meta: {
+   * //     name: "root",
+   * //     content: "Hello"
+   * //   },
+   * //   children: []
+   * // }]
    * ```
    */
-  move(target: TreeID, parent: TreeID | undefined, index?: number | null): void;
+  getShallowValue(): TreeNodeShallowValue[];
   /**
-   * Delete a tree node from the forest.
+   * Set whether to generate a fractional index for moving and creating.
    *
-   * @example
-   * ```ts
-   * import { LoroDoc } from "loro-crdt";
+   * A fractional index can be used to determine the position of tree nodes among their siblings.
    *
-   * const doc = new LoroDoc();
-   * const tree = doc.getTree("tree");
-   * const root = tree.createNode();
-   * const node = root.createNode();
-   * tree.delete(node.id);
-   * ```
+   * The jitter is used to avoid conflicts when multiple users are creating a node at the same position.
+   * A value of 0 is the default, which means no jitter; any value larger than 0 will enable jitter.
+   *
+   * Generally speaking, higher jitter value will increase the size of the operation
+   * [Read more about it](https://www.loro.dev/blog/movable-tree#implementation-and-encoding-size)
    */
-  delete(target: TreeID): void;
+  enableFractionalIndex(jitter: number): void;
   /**
-   * Return `true` if the tree contains the TreeID, include deleted node.
+   * Disable the fractional index generation when you don't need the Tree's siblings to be sorted.
+   * The fractional index will always be set to the same default value 0.
+   *
+   * After calling this, you cannot use `tree.moveTo()`, `tree.moveBefore()`, `tree.moveAfter()`,
+   * and `tree.createAt()`.
    */
-  has(target: TreeID): boolean;
+  disableFractionalIndex(): void;
   /**
-   * Return `None` if the node is not exist, otherwise return `Some(true)` if the node is deleted.
+   * Whether the tree enables the fractional index generation.
    */
-  isNodeDeleted(target: TreeID): boolean;
+  isFractionalIndexEnabled(): boolean;
   /**
-   * Get the hierarchy array with metadata of the forest.
+   * Move the target tree node to be a child of the parent.
+   * It's not allowed that the target is an ancestor of the parent
+   * or the target and the parent are the same node.
    *
    * @example
    * ```ts
@@ -3375,12 +3376,25 @@ export class LoroTree {
    * const doc = new LoroDoc();
    * const tree = doc.getTree("tree");
    * const root = tree.createNode();
-   * root.data.set("color", "red");
-   * // [ { id: '0@F2462C4159C4C8D1', parent: null, meta: { color: 'red' }, children: [] } ]
-   * console.log(tree.toJSON());
+   * const node = root.createNode();
+   * const node2 = node.createNode();
+   * tree.move(node2.id, root.id);
+   * // Error will be thrown if move operation creates a cycle
+   * // tree.move(root.id, node.id);
    * ```
    */
-  toJSON(): any;
+  move(target: TreeID, parent: TreeID | undefined, index?: number | null): void;
+  /**
+   * Create a new detached LoroTree (not attached to any LoroDoc).
+   *
+   * The edits on a detached container will not be persisted.
+   * To attach the container to the document, please insert it into an attached container.
+   */
+  constructor();
+  /**
+   * "Tree"
+   */
+  kind(): 'Tree';
   /**
    * Get all tree nodes of the forest, including deleted nodes.
    *
@@ -3393,103 +3407,61 @@ export class LoroTree {
    * const root = tree.createNode();
    * const node = root.createNode();
    * const node2 = node.createNode();
-   * console.log(tree.nodes());
-   * ```
-   */
-  nodes(): LoroTreeNode[];
-  /**
-   * Get the root nodes of the forest.
-   */
-  roots(): LoroTreeNode[];
-  /**
-   * Get the parent container of the tree container.
-   *
-   * - The parent container of the root tree is `undefined`.
-   * - The object returned is a new js object each time because it need to cross
-   *   the WASM boundary.
-   */
-  parent(): Container | undefined;
-  /**
-   * Whether the container is attached to a document.
-   *
-   * If it's detached, the operations on the container will not be persisted.
+   * console.log(tree.nodes());
+   * ```
    */
-  isAttached(): boolean;
+  nodes(): LoroTreeNode[];
   /**
-   * Get the attached container associated with this.
-   *
-   * Returns an attached `Container` that equals to this or created by this, otherwise `undefined`.
+   * Get the root nodes of the forest.
    */
-  getAttached(): LoroTree | undefined;
+  roots(): LoroTreeNode[];
   /**
-   * Set whether to generate a fractional index for moving and creating.
-   *
-   * A fractional index can be used to determine the position of tree nodes among their siblings.
+   * Delete a tree node from the forest.
    *
-   * The jitter is used to avoid conflicts when multiple users are creating a node at the same position.
-   * A value of 0 is the default, which means no jitter; any value larger than 0 will enable jitter.
+   * @example
+   * ```ts
+   * import { LoroDoc } from "loro-crdt";
    *
-   * Generally speaking, higher jitter value will increase the size of the operation
-   * [Read more about it](https://www.loro.dev/blog/movable-tree#implementation-and-encoding-size)
+   * const doc = new LoroDoc();
+   * const tree = doc.getTree("tree");
+   * const root = tree.createNode();
+   * const node = root.createNode();
+   * tree.delete(node.id);
+   * ```
    */
-  enableFractionalIndex(jitter: number): void;
+  delete(target: TreeID): void;
   /**
-   * Disable the fractional index generation when you don't need the Tree's siblings to be sorted.
-   * The fractional index will always be set to the same default value 0.
+   * Get the parent container of the tree container.
    *
-   * After calling this, you cannot use `tree.moveTo()`, `tree.moveBefore()`, `tree.moveAfter()`,
-   * and `tree.createAt()`.
-   */
-  disableFractionalIndex(): void;
-  /**
-   * Whether the tree enables the fractional index generation.
-   */
-  isFractionalIndexEnabled(): boolean;
-  /**
-   * Check if the container is deleted
+   * - The parent container of the root tree is `undefined`.
+   * - The object returned is a new js object each time because it need to cross
+   *   the WASM boundary.
    */
-  isDeleted(): boolean;
+  parent(): Container | undefined;
   /**
-   * Get the shallow value of the tree.
-   *
-   * Unlike `toJSON()` which recursively resolves nested containers to their values,
-   * `getShallowValue()` returns container IDs as strings for any nested containers.
+   * Get the hierarchy array with metadata of the forest.
    *
    * @example
    * ```ts
+   * import { LoroDoc } from "loro-crdt";
+   *
    * const doc = new LoroDoc();
-   * doc.setPeerId("1");
    * const tree = doc.getTree("tree");
    * const root = tree.createNode();
-   * root.data.set("name", "root");
-   * const text = root.data.setContainer("content", new LoroText());
-   * text.insert(0, "Hello");
-   *
-   * console.log(tree.getShallowValue());
-   * // [{
-   * //   id: "0@1",
-   * //   parent: null,
-   * //   index: 0,
-   * //   fractional_index: "80",
-   * //   meta: "cid:0@1:Map",
-   * //   children: []
-   * // }]
-   *
+   * root.data.set("color", "red");
+   * // [ { id: '0@F2462C4159C4C8D1', parent: null, meta: { color: 'red' }, children: [] } ]
    * console.log(tree.toJSON());
-   * // [{
-   * //   id: "0@1",
-   * //   parent: null,
-   * //   index: 0,
-   * //   fractional_index: "80",
-   * //   meta: {
-   * //     name: "root",
-   * //     content: "Hello"
-   * //   },
-   * //   children: []
-   * // }]
    * ```
    */
-  getShallowValue(): TreeNodeShallowValue[];
+  toJSON(): any;
+  /**
+   * Return `true` if the tree contains the TreeID, include deleted node.
+   */
+  has(target: TreeID): boolean;
+  /**
+   * Check if the container is deleted
+   */
+  isDeleted(): boolean;
   /**
    * Get the id of the container.
    */
@@ -3501,26 +3473,14 @@ export class LoroTree {
 export class LoroTreeNode {
   private constructor();
   free(): void;
-  __getClassname(): string;
   /**
-   * Move the tree node to be after the target node.
-   *
-   * @example
-   * ```ts
-   * import { LoroDoc } from "loro-crdt";
-   *
-   * const doc = new LoroDoc();
-   * const tree = doc.getTree("tree");
-   * const root = tree.createNode();
-   * const node = root.createNode();
-   * const node2 = root.createNode();
-   * node2.moveAfter(node);
-   * // root
-   * //  /  \
-   * // node node2
-   * ```
+   * Get the creation id of this node.
    */
-  moveAfter(target: LoroTreeNode): void;
+  creationId(): { peer: PeerID, counter: number };
+  /**
+   * Check if the node is deleted.
+   */
+  isDeleted(): boolean;
   /**
    * Move the tree node to be before the target node.
    *
@@ -3541,31 +3501,43 @@ export class LoroTreeNode {
    */
   moveBefore(target: LoroTreeNode): void;
   /**
-   * Get the index of the node in the parent's children.
+   * Get the last mover of this node.
    */
-  index(): number | undefined;
+  getLastMoveId(): { peer: PeerID, counter: number } | undefined;
   /**
    * Get the `Fractional Index` of the node.
    *
    * Note: the tree container must be attached to the document.
    */
   fractionalIndex(): string | undefined;
+  __getClassname(): string;
   /**
-   * Check if the node is deleted.
-   */
-  isDeleted(): boolean;
-  /**
-   * Get the last mover of this node.
-   */
-  getLastMoveId(): { peer: PeerID, counter: number } | undefined;
-  /**
-   * Get the creation id of this node.
+   * Get the index of the node in the parent's children.
    */
-  creationId(): { peer: PeerID, counter: number };
+  index(): number | undefined;
   /**
    * Get the creator of this node.
    */
   creator(): PeerID;
+  /**
+   * Move the tree node to be after the target node.
+   *
+   * @example
+   * ```ts
+   * import { LoroDoc } from "loro-crdt";
+   *
+   * const doc = new LoroDoc();
+   * const tree = doc.getTree("tree");
+   * const root = tree.createNode();
+   * const node = root.createNode();
+   * const node2 = root.createNode();
+   * node2.moveAfter(node);
+   * // root
+   * //  /  \
+   * // node node2
+   * ```
+   */
+  moveAfter(target: LoroTreeNode): void;
   /**
    * The TreeID of the node.
    */
@@ -3587,6 +3559,33 @@ export class LoroTreeNode {
  */
 export class UndoManager {
   free(): void;
+  /**
+   * Get the value associated with the top redo stack item, if any.
+   * Returns `undefined` if there is no redo item.
+   */
+  topRedoValue(): Value | undefined;
+  /**
+   * Get the value associated with the top undo stack item, if any.
+   * Returns `undefined` if there is no undo item.
+   */
+  topUndoValue(): Value | undefined;
+  /**
+   * The number of max undo steps.
+   * If the number of undo steps exceeds this number, the oldest undo step will be removed.
+   */
+  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.
+   */
+  setMergeInterval(interval: number): void;
+  /**
+   * If a local event's origin matches the given prefix, it will not be recorded in the
+   * undo stack.
+   */
+  addExcludeOriginPrefix(prefix: string): void;
   /**
    * `UndoManager` is responsible for handling undo and redo operations.
    *
@@ -3611,53 +3610,26 @@ export class UndoManager {
    */
   constructor(doc: LoroDoc, config: UndoConfig);
   /**
-   * Undo the last operation.
+   * Get the peer id of the undo manager.
    */
-  undo(): boolean;
+  peer(): PeerID;
   /**
    * Redo the last undone operation.
    */
   redo(): boolean;
   /**
-   * Get the peer id of the undo manager.
-   */
-  peer(): PeerID;
-  /**
-   * Can undo the last operation.
+   * Undo the last operation.
    */
-  canUndo(): boolean;
+  undo(): boolean;
+  clear(): void;
   /**
    * Can redo the last operation.
    */
   canRedo(): boolean;
   /**
-   * Get the value associated with the top undo stack item, if any.
-   * Returns `undefined` if there is no undo item.
-   */
-  topUndoValue(): Value | undefined;
-  /**
-   * Get the value associated with the top redo stack item, if any.
-   * Returns `undefined` if there is no redo item.
-   */
-  topRedoValue(): Value | undefined;
-  /**
-   * The number of max undo steps.
-   * If the number of undo steps exceeds this number, the oldest undo step will be removed.
-   */
-  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.
-   */
-  setMergeInterval(interval: number): void;
-  /**
-   * If a local event's origin matches the given prefix, it will not be recorded in the
-   * undo stack.
+   * Can undo the last operation.
    */
-  addExcludeOriginPrefix(prefix: string): void;
-  clear(): void;
+  canUndo(): boolean;
 }
 /**
  * [VersionVector](https://en.wikipedia.org/wiki/Version_vector)
@@ -3669,43 +3641,43 @@ export class UndoManager {
 export class VersionVector {
   free(): void;
   /**
-   * Create a new version vector.
+   * Get the counter of a peer.
    */
-  constructor(value: Map<PeerID, number> | Uint8Array | VersionVector | undefined | null);
+  get(peer_id: number | bigint | `${number}`): number | undefined;
   /**
-   * Create a new version vector from a Map.
+   * Create a new version vector.
    */
-  static parseJSON(version: Map<PeerID, number>): VersionVector;
+  constructor(value: Map<PeerID, number> | Uint8Array | VersionVector | undefined | null);
   /**
-   * Convert the version vector to a Map
+   * Decode the version vector from a Uint8Array.
    */
-  toJSON(): Map<PeerID, number>;
+  static decode(bytes: Uint8Array): VersionVector;
   /**
    * Encode the version vector into a Uint8Array.
    */
   encode(): Uint8Array;
+  length(): number;
+  remove(peer: PeerID): void;
   /**
-   * Decode the version vector from a Uint8Array.
-   */
-  static decode(bytes: Uint8Array): VersionVector;
-  /**
-   * Get the counter of a peer.
+   * set the exclusive ending point. target id will NOT be included by self
    */
-  get(peer_id: number | bigint | `${number}`): number | undefined;
+  setEnd(id: { peer: PeerID, counter: number }): void;
   /**
    * Compare the version vector with another version vector.
    *
    * If they are concurrent, return undefined.
    */
   compare(other: VersionVector): number | undefined;
-  /**
-   * set the exclusive ending point. target id will NOT be included by self
-   */
-  setEnd(id: { peer: PeerID, counter: number }): void;
   /**
    * set the inclusive ending point. target id will be included
    */
   setLast(id: { peer: PeerID, counter: number }): void;
-  remove(peer: PeerID): void;
-  length(): number;
+  /**
+   * Convert the version vector to a Map
+   */
+  toJSON(): Map<PeerID, number>;
+  /**
+   * Create a new version vector from a Map.
+   */
+  static parseJSON(version: Map<PeerID, number>): VersionVector;
 }