articulated 0.2.0 → 0.4.0

package/README.md

@@ -109,7 +109,24 @@ let newList = IdList.load(savedState);
 
 IdList stores its state as a modified [B+Tree](https://en.wikipedia.org/wiki/B%2B_tree), described at the top of [its source code](./src/id_list.ts). Each leaf in the B+Tree represents multiple ElementIds (sharing a bunchId and sequential counters) in a compressed way; for normal collaborative text editing, expect 10-20 ElementIds per leaf.
 
-In terms of the number of leaves `L`, mutating an IdList with insertAfter/insertBefore/delete/undelete will only create `O(log(L))` new tree nodes, reusing the rest. However, most methods currently take `O(L)` total time because they search the whole tree for a given ElementId, which has not yet been optimized (it uses a simple depth-first search). Exception: `IdList.at(index)` takes only `O(log(L))` time.
+To speed up searches, we also maintain a "bottom-up" tree that maps from each node to a sequence number identifying its parent. (Using sequence numbers instead of pointers is necessary for persistence.) The map is implemented using persistent balanced trees from [functional-red-black-tree](https://www.npmjs.com/package/functional-red-black-tree).
+
+Asymptotic runtimes are given in terms of the number of leaves `L` and the maximum "fragmentation" of a leaf `F`, which is the number of times its ElementIds alternate between deleted vs present.
+
+- insertAfter, insertBefore: `O(log^2(L) + F)`.
+  - The bottleneck is finding the B+Tree path of the before/after ElementId. This requires `O(log(L))` lookups in the bottom-up tree's map, each of which takes `O(log(L))` time. See the implementation of `IdList.locate`.
+- delete, undelete: `O(log^2(L) + F)`.
+- indexOf: `O(log^2(L) + F)`.
+  - Bottleneck is locating the id.
+- at: `O(log(L) + F)`.
+  - Simple B+Tree search.
+- has, isKnown: `O(log(L) + F)`
+  - Part of the bottom-up tree is a sorted map with leaf keys; due to the sort, we can also use that map to look up the leaf corresponding to an ElementId, in `O(log(L))` time.
+- length: `O(1)`.
+  - Cached.
+- save: `O(S + L)`, where `S <= L * F` is the saved state's length.
+- load: `O(S * log(S))`
+  - The bottleneck is constructing the bottom-up tree: specifically, the map from each leaf to its parent's sequence number (`leafMap`). That map is itself a sorted tree, hence takes `O(L * log(L))` time to construct, and `L <= S`.
 
 If you want to get a sense of what IdList is or how to implement your own version, consider reading the source code for [IdListSimple](./test/id_list_simple.ts), which behaves identically to IdList. It is short (<300 SLOC) and direct, using an array and `Array.splice`. The downside is that IdListSimple does not compress ElementIds, and all of its operations take `O(# ids)` time. We use it as a known-good implementation in our fuzz tests.
 

package/build/commonjs/id_list.d.ts

@@ -1,5 +1,7 @@
 import { SparseIndices } from "sparse-array-rled";
 import { ElementId } from "./id";
+import { MutableLeafMap } from "./internal/leaf_map";
+import { MutableSeqMap } from "./internal/seq_map";
 import { SavedIdList } from "./saved_id_list";
 export interface LeafNode {
     readonly bunchId: string;
@@ -16,19 +18,48 @@ export interface LeafNode {
  * An inner node with inner-node children.
  */
 export declare class InnerNodeInner {
+    /**
+     * A unique identifer for this node within its IdTree.
+     */
+    readonly seq: number;
     readonly children: readonly InnerNode[];
     readonly size: number;
     readonly knownSize: number;
-    constructor(children: readonly InnerNode[]);
+    constructor(
+    /**
+     * A unique identifer for this node within its IdTree.
+     */
+    seq: number, children: readonly InnerNode[], 
+    /**
+     * We add entries for the children to this map, overwriting any existing parentSeqs.
+     *
+     * Pass null to skip when you are doing it yourself. Regardless, you need to
+     * delete any outdated entries yourself.
+     */
+    parentSeqsMut: MutableSeqMap | null);
 }
 /**
  * An inner node with leaf children.
  */
 export declare class InnerNodeLeaf {
+    /**
+     * A unique identifer for this node within its IdTree.
+     */
+    readonly seq: number;
     readonly children: readonly LeafNode[];
     readonly size: number;
     readonly knownSize: number;
-    constructor(children: readonly LeafNode[]);
+    constructor(
+    /**
+     * A unique identifer for this node within its IdTree.
+     */
+    seq: number, children: readonly LeafNode[], 
+    /**
+     * We add entries for the children to this map, overwriting any existing parentSeqs.
+     *
+     * Pass null to skip when you are doing it yourself.
+     */
+    leafMapMut: MutableLeafMap | null);
 }
 export type InnerNode = InnerNodeInner | InnerNodeLeaf;
 /**
@@ -67,6 +98,18 @@ export declare const M = 8;
  */
 export declare class IdList {
     private readonly root;
+    /**
+     * A persistent sorted map from each leaf to its parent node's seq.
+     *
+     * Besides parentSeqs, we also use this to lookup leaves by ElementId.
+     */
+    private readonly leafMap;
+    /**
+     * A persistent map from each InnerNode's seq to its parent node's seq.
+     *
+     * We map the root's seq to 0 (in our constructor).
+     */
+    private readonly parentSeqs;
     /**
      * Internal - construct an IdList using a static method (e.g. `IdList.new`).
      */
@@ -150,6 +193,13 @@ export declare class IdList {
      * @throws If `id` is not known.
      */
     undelete(id: ElementId): IdList;
+    /**
+     * Returns the path from id's leaf node to the root, or null if id is not found.
+     *
+     * The path contains each node and its index in its parent's node, starting with id's
+     * LeafNode and ending at a child of the root.
+     */
+    private locate;
     /**
      * Replaces the leaf at the given path with newLeaves.
      * Returns a proper (sufficiently balanced) B+Tree with updated sizes.
@@ -171,6 +221,10 @@ export declare class IdList {
      * Compare to {@link has}.
      */
     isKnown(id: ElementId): boolean;
+    /**
+     * Returns true if any of the given bulk ids are known.
+     */
+    private isAnyKnown;
     /**
      * The length of the list, counting only present ids.
      *
@@ -270,21 +324,3 @@ export declare class KnownIdView {
      */
     values(): IterableIterator<ElementId>;
 }
-type Located = [
-    {
-        node: LeafNode;
-        indexInParent: number;
-    },
-    ...{
-        node: InnerNode;
-        indexInParent: number;
-    }[]
-];
-/**
- * Returns the path from id's leaf node to the root, or null if id is not found.
- *
- * The path contains each node and its index in its parent's node, starting with id's
- * LeafNode and ending at a child of the root.
- */
-export declare function locate(id: ElementId, node: InnerNode): Located | null;
-export {};

package/build/commonjs/id_list.js

@@ -1,18 +1,35 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.locate = exports.KnownIdView = exports.IdList = exports.M = exports.InnerNodeLeaf = exports.InnerNodeInner = void 0;
+exports.KnownIdView = exports.IdList = exports.M = exports.InnerNodeLeaf = exports.InnerNodeInner = void 0;
 const sparse_array_rled_1 = require("sparse-array-rled");
+const leaf_map_1 = require("./internal/leaf_map");
+const seq_map_1 = require("./internal/seq_map");
 /**
  * An inner node with inner-node children.
  */
 class InnerNodeInner {
-    constructor(children) {
+    constructor(
+    /**
+     * A unique identifer for this node within its IdTree.
+     */
+    seq, children, 
+    /**
+     * We add entries for the children to this map, overwriting any existing parentSeqs.
+     *
+     * Pass null to skip when you are doing it yourself. Regardless, you need to
+     * delete any outdated entries yourself.
+     */
+    parentSeqsMut) {
+        this.seq = seq;
         this.children = children;
         let size = 0;
         let knownSize = 0;
         for (const child of children) {
             size += child.size;
             knownSize += child.knownSize;
+            if (parentSeqsMut) {
+                parentSeqsMut.value = parentSeqsMut.value.set(child.seq, seq);
+            }
         }
         this.size = size;
         this.knownSize = knownSize;
@@ -23,13 +40,27 @@ exports.InnerNodeInner = InnerNodeInner;
  * An inner node with leaf children.
  */
 class InnerNodeLeaf {
-    constructor(children) {
+    constructor(
+    /**
+     * A unique identifer for this node within its IdTree.
+     */
+    seq, children, 
+    /**
+     * We add entries for the children to this map, overwriting any existing parentSeqs.
+     *
+     * Pass null to skip when you are doing it yourself.
+     */
+    leafMapMut) {
+        this.seq = seq;
         this.children = children;
         let size = 0;
         let knownSize = 0;
         for (const child of children) {
             size += child.present.count();
             knownSize += child.count;
+            if (leafMapMut) {
+                leafMapMut.value = leafMapMut.value.set(child, seq);
+            }
         }
         this.size = size;
         this.knownSize = knownSize;
@@ -74,8 +105,16 @@ class IdList {
     /**
      * Internal - construct an IdList using a static method (e.g. `IdList.new`).
      */
-    constructor(root) {
+    constructor(root, 
+    /**
+     * A persistent sorted map from each leaf to its parent node's seq.
+     *
+     * Besides parentSeqs, we also use this to lookup leaves by ElementId.
+     */
+    leafMap, parentSeqs) {
         this.root = root;
+        this.leafMap = leafMap;
+        this.parentSeqs = parentSeqs.set(root.seq, 0);
     }
     /**
      * Constructs an empty list.
@@ -84,7 +123,9 @@ class IdList {
      * or {@link IdList.load}.
      */
     static new() {
-        return new this(new InnerNodeLeaf([]));
+        const leafMapMut = { value: leaf_map_1.LeafMap.new() };
+        const parentSeqsMut = { value: seq_map_1.SeqMap.new() };
+        return new this(new InnerNodeLeaf((0, seq_map_1.getAndBumpNextSeq)(parentSeqsMut), [], leafMapMut), leafMapMut.value, parentSeqsMut.value);
     }
     /**
      * Constructs a list with the given known ids and their isDeleted status, in list order.
@@ -147,7 +188,7 @@ class IdList {
         if (!(Number.isSafeInteger(count) && count >= 0)) {
             throw new Error(`Invalid count: ${count}`);
         }
-        if (count !== 0 && isAnyKnown(newId, count, this.root)) {
+        if (this.isAnyKnown(newId, count)) {
             throw new Error("An inserted id is already known");
         }
         if (before === null) {
@@ -157,21 +198,21 @@ class IdList {
                 // Insert the first leaf as a child of root.
                 const present = sparse_array_rled_1.SparseIndices.new();
                 present.set(newId.counter, count);
-                return new IdList(new InnerNodeLeaf([
-                    {
-                        bunchId: newId.bunchId,
-                        startCounter: newId.counter,
-                        count,
-                        present,
-                    },
-                ]));
+                const leaf = {
+                    bunchId: newId.bunchId,
+                    startCounter: newId.counter,
+                    count,
+                    present,
+                };
+                const leafMapMut = { value: this.leafMap };
+                return new IdList(new InnerNodeLeaf(this.root.seq, [leaf], leafMapMut), leafMapMut.value, this.parentSeqs);
             }
             else {
                 // Insert before the first known id.
                 return this.insertBefore(firstId(this.root), newId, count);
             }
         }
-        const located = locate(before, this.root);
+        const located = this.locate(before);
         if (located === null) {
             throw new Error("before is not known");
         }
@@ -247,7 +288,7 @@ class IdList {
         if (!(Number.isSafeInteger(count) && count >= 0)) {
             throw new Error(`Invalid count: ${count}`);
         }
-        if (count !== 0 && isAnyKnown(newId, count, this.root)) {
+        if (this.isAnyKnown(newId, count)) {
             throw new Error("An inserted id is already known");
         }
         if (after === null) {
@@ -256,7 +297,7 @@ class IdList {
             // Insert after the last known id, or at the beginning if empty.
             return this.insertAfter(this.root.knownSize === 0 ? null : lastId(this.root), newId, count);
         }
-        const located = locate(after, this.root);
+        const located = this.locate(after);
         if (located === null) {
             throw new Error("after is not known");
         }
@@ -323,7 +364,7 @@ class IdList {
      * If `id` is already deleted or is not known, this method does nothing.
      */
     delete(id) {
-        const located = locate(id, this.root);
+        const located = this.locate(id);
         if (located === null)
             return this;
         const leaf = located[0].node;
@@ -344,7 +385,7 @@ class IdList {
      * @throws If `id` is not known.
      */
     undelete(id) {
-        const located = locate(id, this.root);
+        const located = this.locate(id);
         if (located === null) {
             throw new Error("id is not known");
         }
@@ -355,6 +396,52 @@ class IdList {
         newPresent.set(id.counter);
         return this.replaceLeaf(located, { ...leaf, present: newPresent });
     }
+    /**
+     * Returns the path from id's leaf node to the root, or null if id is not found.
+     *
+     * The path contains each node and its index in its parent's node, starting with id's
+     * LeafNode and ending at a child of the root.
+     */
+    locate(id) {
+        // Find the leaf containing id, if any.
+        const [leaf, parentSeq] = this.leafMap.getLeaf(id.bunchId, id.counter);
+        if (leaf === undefined)
+            return null;
+        if (!(leaf.bunchId === id.bunchId &&
+            leaf.startCounter <= id.counter &&
+            id.counter < leaf.startCounter + leaf.count)) {
+            return null;
+        }
+        // Find the seqs on the path (leaf, root].
+        const innerSeqs = [];
+        let curSeq = parentSeq;
+        while (curSeq !== 0) {
+            innerSeqs.push(curSeq);
+            curSeq = this.parentSeqs.get(curSeq);
+        }
+        // Find the nodes and indexInParent's on the path (root, leaf),
+        // using seqs to find the appropriate child of each node.
+        const innerNodes = [];
+        let curParent = this.root;
+        // Start at the root child's seq and proceed to the leaf parent's seq.
+        for (let i = innerSeqs.length - 2; i >= 0; i--) {
+            const children = curParent.children;
+            const childIndex = children.findIndex((child) => child.seq === innerSeqs[i]);
+            if (childIndex === -1)
+                throw new Error("Internal error");
+            const child = children[childIndex];
+            innerNodes.push({ node: child, indexInParent: childIndex });
+            curParent = child;
+        }
+        // Now curParent is the leaf's parent. Find leaf in its children and return.
+        const leafChildIndex = curParent.children.indexOf(leaf);
+        if (leafChildIndex === -1)
+            throw new Error("Internal error");
+        return [
+            { node: leaf, indexInParent: leafChildIndex },
+            ...innerNodes.reverse(),
+        ];
+    }
     /**
      * Replaces the leaf at the given path with newLeaves.
      * Returns a proper (sufficiently balanced) B+Tree with updated sizes.
@@ -362,7 +449,10 @@ class IdList {
      * newLeaves.length must be in [1, M].
      */
     replaceLeaf(located, ...newLeaves) {
-        return new IdList(replaceNode(located, this.root, newLeaves, 0));
+        const leafMapMut = { value: this.leafMap };
+        const parentSeqsMut = { value: this.parentSeqs };
+        const newRoot = replaceNode(located, this.root, leafMapMut, parentSeqsMut, newLeaves, 0);
+        return new IdList(newRoot, leafMapMut.value, parentSeqsMut.value);
     }
     // Accessors
     /**
@@ -373,10 +463,12 @@ class IdList {
      * Compare to {@link isKnown}.
      */
     has(id) {
-        const located = locate(id, this.root);
-        if (located === null)
-            return false;
-        return located[0].node.present.has(id.counter);
+        // Find the LeafNode that would contain id if known.
+        const [leaf] = this.leafMap.getLeaf(id.bunchId, id.counter);
+        if (leaf && leaf.bunchId === id.bunchId) {
+            return leaf.present.has(id.counter);
+        }
+        return false;
     }
     /**
      * Returns whether id is known to this list.
@@ -384,7 +476,34 @@ class IdList {
      * Compare to {@link has}.
      */
     isKnown(id) {
-        return locate(id, this.root) !== null;
+        // Find the LeafNode that would contain id if known.
+        const [leaf] = this.leafMap.getLeaf(id.bunchId, id.counter);
+        if (leaf && leaf.bunchId === id.bunchId) {
+            return (leaf.startCounter <= id.counter &&
+                id.counter < leaf.startCounter + leaf.count);
+        }
+        return false;
+    }
+    // TODO: Make public?
+    /**
+     * Returns true if any of the given bulk ids are known.
+     */
+    isAnyKnown(id, count) {
+        if (count === 0)
+            return false;
+        // Find the leaf containing the last id, or the previous leaf.
+        // If any leaf knows any of the ids, this leaf must know an id too.
+        const [leaf] = this.leafMap.getLeaf(id.bunchId, id.counter + count - 1);
+        if (leaf && leaf.bunchId === id.bunchId) {
+            // Test if there is any overlap between the leaf's counter range [a, b]
+            // and the bulk ids' counter range [c, d].
+            const a = leaf.startCounter;
+            const b = leaf.startCounter + leaf.count - 1;
+            const c = id.counter;
+            const d = id.counter + count - 1;
+            return a <= d && c <= b;
+        }
+        return false;
     }
     /**
      * The length of the list, counting only present ids.
@@ -449,7 +568,7 @@ class IdList {
      * @throws If `id` is not known.
      */
     indexOf(id, bias = "none") {
-        const located = locate(id, this.root);
+        const located = this.locate(id);
         if (located === null)
             throw new Error("id is not known");
         /**
@@ -530,7 +649,7 @@ class IdList {
      * Loads a saved state returned by {@link save}.
      */
     static load(savedState) {
-        // 1. Determine the leaves.
+        // 1. Determine the leaves in list order.
         const leaves = [];
         for (let i = 0; i < savedState.length; i++) {
             const item = savedState[i];
@@ -568,16 +687,23 @@ class IdList {
             });
         }
         // 2. Create a B+Tree with the given leaves.
-        // We do a "direct" balanced construction that takes O(n) time, instead of inserting
-        // leaves one-by-one, which would take O(n log(n)) time.
+        // We do a "direct" balanced construction that takes O(L) time, instead of inserting
+        // leaves one-by-one, which would take O(L log(L)) time.
+        // However, constructing the sorted leafMap brings the overall runtime to O(L log(L)).
         if (leaves.length === 0)
             return IdList.new();
+        // TODO: Test the aux data structures after loading.
+        // E.g. reload and then call checkAll again.
+        // Also should do insertions to test splitting of the full tree.
+        const leafMapMut = { value: leaf_map_1.LeafMap.new() };
+        const parentSeqsMut = { value: seq_map_1.SeqMap.new() };
         // Depth of the B+Tree (number of non-root nodes on any path from a leaf to the root).
-        // A fully balanced B+Tree of depth d has between [M^{d-1} + 1, M^d] leaves.
+        // A full B+Tree of depth d has between [M^{d-1} + 1, M^d] leaves.
         const depth = leaves.length === 1
             ? 1
             : Math.ceil(Math.log(leaves.length) / Math.log(exports.M));
-        return new IdList(buildTree(leaves, 0, depth));
+        const root = buildTree(leaves, leafMapMut, parentSeqsMut, 0, depth);
+        return new IdList(root, leafMapMut.value, parentSeqsMut.value);
     }
 }
 exports.IdList = IdList;
@@ -647,7 +773,8 @@ class KnownIdView {
      * Returns the index of `id` in this view, or -1 if it is not known.
      */
     indexOf(id) {
-        const located = locate(id, this.root);
+        // @ts-expect-error Ignore private
+        const located = this.list.locate(id);
         if (located === null)
             throw new Error("id is not known");
         /**
@@ -722,70 +849,15 @@ function lastId(node) {
         counter: lastLeaf.startCounter + lastLeaf.count - 1,
     };
 }
-/**
- * Returns the path from id's leaf node to the root, or null if id is not found.
- *
- * The path contains each node and its index in its parent's node, starting with id's
- * LeafNode and ending at a child of the root.
- */
-function locate(id, node) {
-    if (node instanceof InnerNodeInner) {
-        for (let i = 0; i < node.children.length; i++) {
-            const child = node.children[i];
-            const childLocated = locate(id, child);
-            if (childLocated !== null) {
-                childLocated.push({ node: child, indexInParent: i });
-                return childLocated;
-            }
-        }
-    }
-    else {
-        for (let i = 0; i < node.children.length; i++) {
-            const child = node.children[i];
-            if (child.bunchId === id.bunchId &&
-                child.startCounter <= id.counter &&
-                id.counter < child.startCounter + child.count) {
-                return [{ node: child, indexInParent: i }];
-            }
-        }
-    }
-    return null;
-}
-exports.locate = locate;
-/**
- * Returns true if any of the given bulk ids are known within node's subtree.
- *
- * Assumes count > 0.
- */
-function isAnyKnown(id, count, node) {
-    if (node instanceof InnerNodeInner) {
-        for (const child of node.children) {
-            if (isAnyKnown(id, count, child))
-                return true;
-        }
-    }
-    else {
-        for (const child of node.children) {
-            if (child.bunchId === id.bunchId) {
-                // Test if there is any overlap between the child's counter range [a, b]
-                // and the bulk id's counter range [c, d].
-                const a = child.startCounter;
-                const b = child.startCounter + child.count - 1;
-                const c = id.counter;
-                const d = id.counter + count - 1;
-                if (a <= d && c <= b)
-                    return true;
-            }
-        }
-    }
-    return false;
-}
 /**
  * Replace located[i].node with newNodes.
  *
  * newNodes.length must be in [1, M].
+ *
+ * The returned node's descendants are recorded in leafMapMut and parentSeqsMut,
+ * but the node itself is not (since we don't know its parent here).
  */
-function replaceNode(located, root, newNodes, i) {
+function replaceNode(located, root, leafMapMut, parentSeqsMut, newNodes, i) {
     const parent = i === located.length - 1 ? root : located[i + 1].node;
     const indexInParent = located[i].indexInParent;
     // Copy-on-write version of parent.children.splice(indexInParent, 1, ...newNodes)
@@ -794,31 +866,54 @@ function replaceNode(located, root, newNodes, i) {
         .concat(newNodes, parent.children.slice(indexInParent + 1));
     if (newChildren.length > exports.M) {
         // Split the parent to maintain BTree property (# children <= M).
+        // Treat the right parent as "new", getting a new seq.
         const split = Math.ceil(newChildren.length / 2);
+        const seqs = [parent.seq, (0, seq_map_1.getAndBumpNextSeq)(parentSeqsMut)];
         const newParents = [
             newChildren.slice(0, split),
             newChildren.slice(split),
-        ].map((children) => i === 0
-            ? new InnerNodeLeaf(children)
-            : new InnerNodeInner(children));
+        ].map((children, j) => i === 0
+            ? new InnerNodeLeaf(seqs[j], children, leafMapMut)
+            : new InnerNodeInner(seqs[j], children, parentSeqsMut));
         if (i === located.length - 1) {
             // newParents replace root. We need a new root to hold them.
-            return new InnerNodeInner(newParents);
+            return new InnerNodeInner((0, seq_map_1.getAndBumpNextSeq)(parentSeqsMut), newParents, parentSeqsMut);
         }
         else {
-            return replaceNode(located, root, newParents, i + 1);
+            return replaceNode(located, root, leafMapMut, parentSeqsMut, newParents, i + 1);
         }
     }
     else {
-        const newParent = i === 0
-            ? new InnerNodeLeaf(newChildren)
-            : new InnerNodeInner(newChildren);
+        // "Replace" parent, reusing its seq.
+        // To avoid doing newChildren.length sets every time (which makes replaceLeaf
+        // do >=(M/2)*log(L) total sets, even when none were necessary),
+        // we bypass the InnerNode constructors' leafMap/parentSeq operations,
+        // instead doing them ourselves only on the changed children.
+        let newParent;
+        if (i === 0) {
+            newParent = new InnerNodeLeaf(parent.seq, newChildren, null);
+            // Important to delete the replaced leaf's entry, so that it doesn't corrupt by-ElementId searches.
+            leafMapMut.value = leafMapMut.value.delete(located[0].node);
+            for (const newNode of newNodes) {
+                leafMapMut.value = leafMapMut.value.set(newNode, parent.seq);
+            }
+        }
+        else {
+            newParent = new InnerNodeInner(parent.seq, newChildren, null);
+            for (const newNode of newNodes) {
+                if (newNode.seq !== located[i].node.seq) {
+                    parentSeqsMut.value = parentSeqsMut.value.set(newNode.seq, parent.seq);
+                }
+            }
+            // If the replaced node isn't represented in newNodes (i.e., same seq is not reused),
+            // we could delete its entry to save memory, but it is not necessary.
+        }
         if (i === located.length - 1) {
             // Replaces root.
             return newParent;
         }
         else {
-            return replaceNode(located, root, [newParent], i + 1);
+            return replaceNode(located, root, leafMapMut, parentSeqsMut, [newParent], i + 1);
         }
     }
 }
@@ -962,13 +1057,18 @@ function pushSaveItem(acc, item) {
 /**
  * Builds a tree with the given leaves. Used by IdList.load.
  *
- * In contrast to inserting the leaves one-by-one, this function balances the
- * tree, with full inner nodes (M children) whenever possible,
- * and runs in O(L) time instead of O(L log(L)).
+ * The returned node's descendants are recorded in leafMapMut and parentSeqsMut,
+ * but not the node itself (since we don't know its parent here).
+ *
+ * In contrast to inserting the leaves one-by-one, this function fills nodes
+ * with M children whenever possible,
+ * and the B+Tree parts run in O(L) time instead of O(L log(L)).
+ * However, the overall runtime is O(L log(L)) from constructing the sorted leafMap.
  */
-function buildTree(leaves, startIndex, depthRemaining) {
+function buildTree(leaves, leafMapMut, parentSeqsMut, startIndex, depthRemaining) {
+    const parentSeq = (0, seq_map_1.getAndBumpNextSeq)(parentSeqsMut);
     if (depthRemaining === 1) {
-        return new InnerNodeLeaf(leaves.slice(startIndex, startIndex + exports.M));
+        return new InnerNodeLeaf(parentSeq, leaves.slice(startIndex, startIndex + exports.M), leafMapMut);
     }
     else {
         const children = [];
@@ -977,9 +1077,9 @@ function buildTree(leaves, startIndex, depthRemaining) {
             const childStartIndex = startIndex + i * childLeafCount;
             if (childStartIndex >= leaves.length)
                 break;
-            children.push(buildTree(leaves, childStartIndex, depthRemaining - 1));
+            children.push(buildTree(leaves, leafMapMut, parentSeqsMut, childStartIndex, depthRemaining - 1));
         }
-        return new InnerNodeInner(children);
+        return new InnerNodeInner(parentSeq, children, parentSeqsMut);
     }
 }
 //# sourceMappingURL=id_list.js.map