serializable-bptree 7.0.0 → 7.0.1

package/dist/esm/index.mjs

@@ -439,6 +439,20 @@ var BPTree = class _BPTree {
   option;
   order;
   rootId;
+  /**
+   * Returns the ID of the root node.
+   * @returns The root node ID.
+   */
+  getRootId() {
+    return this.rootId;
+  }
+  /**
+   * Returns the order of the B+Tree.
+   * @returns The order of the tree.
+   */
+  getOrder() {
+    return this.order;
+  }
   _strategyDirty;
   _nodeCreateBuffer;
   _nodeUpdateBuffer;
@@ -671,24 +685,21 @@ var BPTree = class _BPTree {
             break;
           }
           keys.push(key);
-          this.bufferForNodeUpdate(node);
-          break;
+          return this.bufferForNodeUpdate(node);
         } else if (this.comparator.isLower(value, nValue)) {
           node.values.splice(i, 0, value);
           node.keys.splice(i, 0, [key]);
-          this.bufferForNodeUpdate(node);
-          break;
+          return this.bufferForNodeUpdate(node);
         } else if (i + 1 === node.values.length) {
           node.values.push(value);
           node.keys.push([key]);
-          this.bufferForNodeUpdate(node);
-          break;
+          return this.bufferForNodeUpdate(node);
         }
       }
     } else {
       node.values = [value];
       node.keys = [[key]];
-      this.bufferForNodeUpdate(node);
+      return this.bufferForNodeUpdate(node);
     }
   }
   bufferForNodeCreate(node) {
@@ -804,7 +815,7 @@ var BPTreeSyncBase = class extends BPTree {
     }
     return id;
   }
-  _createNode(isLeaf, keys, values, leaf = false, parent = null, next = null, prev = null) {
+  _createNode(isLeaf, keys, values, leaf = isLeaf, parent = null, next = null, prev = null) {
     const id = this._createNodeId(isLeaf);
     const node = {
       id,
@@ -815,26 +826,23 @@ var BPTreeSyncBase = class extends BPTree {
       next,
       prev
     };
-    this._nodeCreateBuffer.set(id, node);
+    this.bufferForNodeCreate(node);
     return node;
   }
   _deleteEntry(node, key, value) {
     if (!node.leaf) {
+      let keyIndex = -1;
       for (let i = 0, len = node.keys.length; i < len; i++) {
-        const nKey = node.keys[i];
-        if (nKey === key) {
-          node.keys.splice(i, 1);
-          this.bufferForNodeUpdate(node);
+        if (node.keys[i] === key) {
+          keyIndex = i;
           break;
         }
       }
-      for (let i = 0, len = node.values.length; i < len; i++) {
-        const nValue = node.values[i];
-        if (this.comparator.isSame(value, nValue)) {
-          node.values.splice(i, 1);
-          this.bufferForNodeUpdate(node);
-          break;
-        }
+      if (keyIndex !== -1) {
+        node.keys.splice(keyIndex, 1);
+        const valueIndex = keyIndex > 0 ? keyIndex - 1 : 0;
+        node.values.splice(valueIndex, 1);
+        this.bufferForNodeUpdate(node);
       }
     }
     if (this.rootId === node.id && node.keys.length === 1 && !node.leaf) {
@@ -934,13 +942,10 @@ var BPTreeSyncBase = class extends BPTree {
             node.keys = [pointerPm, ...node.keys];
             node.values = [guess, ...node.values];
             parentNode = this.getNode(node.parent);
-            for (let i = 0, len = parentNode.values.length; i < len; i++) {
-              const nValue = parentNode.values[i];
-              if (this.comparator.isSame(guess, nValue)) {
-                parentNode.values[i] = pointerKm;
-                this.bufferForNodeUpdate(parentNode);
-                break;
-              }
+            const nodeIndex = parentNode.keys.indexOf(node.id);
+            if (nodeIndex > 0) {
+              parentNode.values[nodeIndex - 1] = pointerKm;
+              this.bufferForNodeUpdate(parentNode);
             }
           } else {
             pointerPm = pointer.keys.splice(-1)[0];
@@ -948,13 +953,10 @@ var BPTreeSyncBase = class extends BPTree {
             node.keys = [pointerPm, ...node.keys];
             node.values = [pointerKm, ...node.values];
             parentNode = this.getNode(node.parent);
-            for (let i = 0, len = parentNode.values.length; i < len; i++) {
-              const nValue = parentNode.values[i];
-              if (this.comparator.isSame(guess, nValue)) {
-                parentNode.values[i] = pointerKm;
-                this.bufferForNodeUpdate(parentNode);
-                break;
-              }
+            const nodeIndex = parentNode.keys.indexOf(node.id);
+            if (nodeIndex > 0) {
+              parentNode.values[nodeIndex - 1] = pointerKm;
+              this.bufferForNodeUpdate(parentNode);
             }
           }
           this.bufferForNodeUpdate(node);
@@ -968,13 +970,10 @@ var BPTreeSyncBase = class extends BPTree {
             node.keys = [...node.keys, pointerP0];
             node.values = [...node.values, guess];
             parentNode = this.getNode(node.parent);
-            for (let i = 0, len = parentNode.values.length; i < len; i++) {
-              const nValue = parentNode.values[i];
-              if (this.comparator.isSame(guess, nValue)) {
-                parentNode.values[i] = pointerK0;
-                this.bufferForNodeUpdate(parentNode);
-                break;
-              }
+            const pointerIndex = parentNode.keys.indexOf(pointer.id);
+            if (pointerIndex > 0) {
+              parentNode.values[pointerIndex - 1] = pointerK0;
+              this.bufferForNodeUpdate(parentNode);
             }
           } else {
             pointerP0 = pointer.keys.splice(0, 1)[0];
@@ -982,13 +981,10 @@ var BPTreeSyncBase = class extends BPTree {
             node.keys = [...node.keys, pointerP0];
             node.values = [...node.values, pointerK0];
             parentNode = this.getNode(node.parent);
-            for (let i = 0, len = parentNode.values.length; i < len; i++) {
-              const nValue = parentNode.values[i];
-              if (this.comparator.isSame(guess, nValue)) {
-                parentNode.values[i] = pointer.values[0];
-                this.bufferForNodeUpdate(parentNode);
-                break;
-              }
+            const pointerIndex = parentNode.keys.indexOf(pointer.id);
+            if (pointerIndex > 0) {
+              parentNode.values[pointerIndex - 1] = pointer.values[0];
+              this.bufferForNodeUpdate(parentNode);
             }
           }
           this.bufferForNodeUpdate(node);
@@ -1016,6 +1012,8 @@ var BPTreeSyncBase = class extends BPTree {
           }
         }
       }
+    } else {
+      this.bufferForNodeUpdate(node);
     }
   }
   _insertInParent(node, value, pointer) {
@@ -1034,31 +1032,25 @@ var BPTreeSyncBase = class extends BPTree {
       return;
     }
     const parentNode = this.getNode(node.parent);
-    let insertIndex = 0;
-    for (let i = 0; i < parentNode.values.length; i++) {
-      if (this.comparator.asc(value, parentNode.values[i]) > 0) {
-        insertIndex = i + 1;
-      } else {
-        break;
-      }
+    const nodeIndex = parentNode.keys.indexOf(node.id);
+    if (nodeIndex === -1) {
+      throw new Error(`Node ${node.id} not found in parent ${parentNode.id}`);
     }
+    const insertIndex = nodeIndex;
     parentNode.values.splice(insertIndex, 0, value);
     parentNode.keys.splice(insertIndex + 1, 0, pointer.id);
     pointer.parent = parentNode.id;
     if (pointer.leaf) {
-      const leftSiblingId = parentNode.keys[insertIndex];
-      const rightSiblingId = parentNode.keys[insertIndex + 2];
-      if (leftSiblingId) {
-        const leftSibling = this.getNode(leftSiblingId);
-        pointer.prev = leftSibling.id;
-        pointer.next = leftSibling.next;
-        leftSibling.next = pointer.id;
-        this.bufferForNodeUpdate(leftSibling);
-      }
-      if (rightSiblingId) {
-        const rightSibling = this.getNode(rightSiblingId);
-        rightSibling.prev = pointer.id;
-        this.bufferForNodeUpdate(rightSibling);
+      const leftSibling = node;
+      const oldNextId = leftSibling.next;
+      pointer.prev = leftSibling.id;
+      pointer.next = oldNextId;
+      leftSibling.next = pointer.id;
+      this.bufferForNodeUpdate(leftSibling);
+      if (oldNextId) {
+        const oldNext = this.getNode(oldNextId);
+        oldNext.prev = pointer.id;
+        this.bufferForNodeUpdate(oldNext);
       }
     }
     this.bufferForNodeUpdate(parentNode);
@@ -1087,6 +1079,7 @@ var BPTreeSyncBase = class extends BPTree {
     }
   }
   init() {
+    this.clear();
     const head = this.strategy.readHead();
     if (head === null) {
       this.order = this.strategy.order;
@@ -1117,18 +1110,35 @@ var BPTreeSyncBase = class extends BPTree {
   }
   insertableNode(value) {
     let node = this.getNode(this.rootId);
+    if (node.parent !== null) {
+      node.parent = null;
+      this.bufferForNodeUpdate(node);
+    }
     while (!node.leaf) {
+      const parentId = node.id;
       for (let i = 0, len = node.values.length; i < len; i++) {
         const nValue = node.values[i];
         const k = node.keys;
         if (this.comparator.isSame(value, nValue)) {
           node = this.getNode(k[i + 1]);
+          if (node.parent !== parentId) {
+            node.parent = parentId;
+            this.bufferForNodeUpdate(node);
+          }
           break;
         } else if (this.comparator.isLower(value, nValue)) {
           node = this.getNode(k[i]);
+          if (node.parent !== parentId) {
+            node.parent = parentId;
+            this.bufferForNodeUpdate(node);
+          }
           break;
         } else if (i + 1 === node.values.length) {
           node = this.getNode(k[i + 1]);
+          if (node.parent !== parentId) {
+            node.parent = parentId;
+            this.bufferForNodeUpdate(node);
+          }
           break;
         }
       }
@@ -1137,18 +1147,35 @@ var BPTreeSyncBase = class extends BPTree {
   }
   insertableNodeByPrimary(value) {
     let node = this.getNode(this.rootId);
+    if (node.parent !== null) {
+      node.parent = null;
+      this.bufferForNodeUpdate(node);
+    }
     while (!node.leaf) {
+      const parentId = node.id;
       for (let i = 0, len = node.values.length; i < len; i++) {
         const nValue = node.values[i];
         const k = node.keys;
         if (this.comparator.isPrimarySame(value, nValue)) {
           node = this.getNode(k[i]);
+          if (node.parent !== parentId) {
+            node.parent = parentId;
+            this.bufferForNodeUpdate(node);
+          }
           break;
         } else if (this.comparator.isPrimaryLower(value, nValue)) {
           node = this.getNode(k[i]);
+          if (node.parent !== parentId) {
+            node.parent = parentId;
+            this.bufferForNodeUpdate(node);
+          }
           break;
         } else if (i + 1 === node.values.length) {
           node = this.getNode(k[i + 1]);
+          if (node.parent !== parentId) {
+            node.parent = parentId;
+            this.bufferForNodeUpdate(node);
+          }
           break;
         }
       }
@@ -1157,16 +1184,29 @@ var BPTreeSyncBase = class extends BPTree {
   }
   insertableRightestNodeByPrimary(value) {
     let node = this.getNode(this.rootId);
+    if (node.parent !== null) {
+      node.parent = null;
+      this.bufferForNodeUpdate(node);
+    }
     while (!node.leaf) {
+      const parentId = node.id;
       for (let i = 0, len = node.values.length; i < len; i++) {
         const nValue = node.values[i];
         const k = node.keys;
         if (this.comparator.isPrimaryLower(value, nValue)) {
           node = this.getNode(k[i]);
+          if (node.parent !== parentId) {
+            node.parent = parentId;
+            this.bufferForNodeUpdate(node);
+          }
           break;
         }
         if (i + 1 === node.values.length) {
           node = this.getNode(k[i + 1]);
+          if (node.parent !== parentId) {
+            node.parent = parentId;
+            this.bufferForNodeUpdate(node);
+          }
           break;
         }
       }
@@ -1201,17 +1241,35 @@ var BPTreeSyncBase = class extends BPTree {
   }
   leftestNode() {
     let node = this.getNode(this.rootId);
+    if (node.parent !== null) {
+      node.parent = null;
+      this.bufferForNodeUpdate(node);
+    }
     while (!node.leaf) {
+      const parentId = node.id;
       const keys = node.keys;
       node = this.getNode(keys[0]);
+      if (node.parent !== parentId) {
+        node.parent = parentId;
+        this.bufferForNodeUpdate(node);
+      }
     }
     return node;
   }
   rightestNode() {
     let node = this.getNode(this.rootId);
+    if (node.parent !== null) {
+      node.parent = null;
+      this.bufferForNodeUpdate(node);
+    }
     while (!node.leaf) {
+      const parentId = node.id;
       const keys = node.keys;
       node = this.getNode(keys[keys.length - 1]);
+      if (node.parent !== parentId) {
+        node.parent = parentId;
+        this.bufferForNodeUpdate(node);
+      }
     }
     return node;
   }
@@ -1550,23 +1608,37 @@ var BPTreeSyncTransaction = class extends BPTreeSyncBase {
   realBaseTree;
   realBaseStrategy;
   txNodes = /* @__PURE__ */ new Map();
-  dirtyIds = /* @__PURE__ */ new Set();
-  createdInTx = /* @__PURE__ */ new Set();
+  dirtyIds;
+  createdInTx;
+  deletedIds;
   initialRootId;
   transactionRootId;
   constructor(baseTree) {
     super(baseTree.strategy, baseTree.comparator, baseTree.option);
     this.realBaseTree = baseTree;
     this.realBaseStrategy = baseTree.strategy;
+    this.order = baseTree.getOrder();
     this.initialRootId = "";
     this.transactionRootId = "";
+    this.dirtyIds = /* @__PURE__ */ new Set();
+    this.createdInTx = /* @__PURE__ */ new Set();
+    this.deletedIds = /* @__PURE__ */ new Set();
   }
   /**
    * Initializes the transaction by capturing the current state of the tree.
    */
   initTransaction() {
     const head = this.realBaseStrategy.readHead();
-    this.initialRootId = head?.root ?? this.realBaseTree.rootId;
+    if (head) {
+      this.order = head.order;
+      this.initialRootId = head.root;
+    } else {
+      this.initialRootId = this.realBaseTree.getRootId();
+    }
+    if (!this.initialRootId) {
+      const root = this._createNode(true, [], [], true);
+      this.initialRootId = root.id;
+    }
     this.transactionRootId = this.initialRootId;
     this.rootId = this.transactionRootId;
     const snapshotStrategy = new BPTreeSyncSnapshotStrategy(this.realBaseStrategy, this.initialRootId);
@@ -1574,34 +1646,76 @@ var BPTreeSyncTransaction = class extends BPTreeSyncBase {
     this.txNodes.clear();
     this.dirtyIds.clear();
     this.createdInTx.clear();
+    this.deletedIds.clear();
   }
   getNode(id) {
     if (this.txNodes.has(id)) {
       return this.txNodes.get(id);
     }
+    if (this.deletedIds.has(id)) {
+      throw new Error(`The tree attempted to reference deleted node '${id}'`);
+    }
     const baseNode = this.realBaseStrategy.read(id);
     const clone = JSON.parse(JSON.stringify(baseNode));
     this.txNodes.set(id, clone);
     return clone;
   }
   bufferForNodeUpdate(node) {
+    if (this.dirtyIds.has(node.id) && this.txNodes.has(node.id) && node._p) {
+      this.txNodes.set(node.id, node);
+      return;
+    }
+    node._p = true;
     this.txNodes.set(node.id, node);
     this.dirtyIds.add(node.id);
+    if (node.leaf) {
+      if (node.next && !this.dirtyIds.has(node.next) && !this.deletedIds.has(node.next)) {
+        try {
+          this.bufferForNodeUpdate(this.getNode(node.next));
+        } catch (e) {
+        }
+      }
+      if (node.prev && !this.dirtyIds.has(node.prev) && !this.deletedIds.has(node.prev)) {
+        try {
+          this.bufferForNodeUpdate(this.getNode(node.prev));
+        } catch (e) {
+        }
+      }
+    }
     this.markPathDirty(node);
+    delete node._p;
   }
   bufferForNodeCreate(node) {
     this.txNodes.set(node.id, node);
     this.dirtyIds.add(node.id);
     this.createdInTx.add(node.id);
+    if (node.leaf) {
+      if (node.next && !this.dirtyIds.has(node.next) && !this.deletedIds.has(node.next)) {
+        try {
+          this.bufferForNodeUpdate(this.getNode(node.next));
+        } catch (e) {
+        }
+      }
+      if (node.prev && !this.dirtyIds.has(node.prev) && !this.deletedIds.has(node.prev)) {
+        try {
+          this.bufferForNodeUpdate(this.getNode(node.prev));
+        } catch (e) {
+        }
+      }
+    }
     this.markPathDirty(node);
   }
   bufferForNodeDelete(node) {
     this.txNodes.delete(node.id);
     this.dirtyIds.add(node.id);
+    this.deletedIds.add(node.id);
   }
   markPathDirty(node) {
     let curr = node;
     while (curr.parent) {
+      if (this.deletedIds.has(curr.parent)) {
+        break;
+      }
       if (this.dirtyIds.has(curr.parent) && this.txNodes.has(curr.parent)) {
         break;
       }
@@ -1613,13 +1727,13 @@ var BPTreeSyncTransaction = class extends BPTreeSyncBase {
       this.transactionRootId = curr.id;
     }
   }
-  _createNode(isLeaf, keys, values, leaf = false, parent = null, next = null, prev = null) {
-    const id = this.realBaseStrategy.id(isLeaf);
+  _createNode(isLeaf, keys, values, leaf = isLeaf, parent = null, next = null, prev = null) {
+    const id = this.strategy.id(isLeaf);
     const node = {
       id,
       keys,
       values,
-      leaf: isLeaf,
+      leaf,
       parent,
       next,
       prev
@@ -1677,9 +1791,9 @@ var BPTreeSyncTransaction = class extends BPTreeSyncBase {
       finalNodes.push(node);
       newCreatedIds.push(newId);
     }
-    let newRootId = this.transactionRootId;
-    if (idMapping.has(this.transactionRootId)) {
-      newRootId = idMapping.get(this.transactionRootId);
+    let newRootId = this.rootId;
+    if (idMapping.has(this.rootId)) {
+      newRootId = idMapping.get(this.rootId);
     }
     for (const node of finalNodes) {
       this.realBaseStrategy.write(node.id, node);
@@ -1730,6 +1844,7 @@ var BPTreeSyncTransaction = class extends BPTreeSyncBase {
 var BPTreeSync = class extends BPTreeSyncBase {
   constructor(strategy, comparator, option) {
     super(strategy, comparator, option);
+    this.init();
   }
   /**
    * Creates a new synchronous transaction.
@@ -1837,7 +1952,7 @@ var BPTreeAsyncBase = class extends BPTree {
     }
     return id;
   }
-  async _createNode(isLeaf, keys, values, leaf = false, parent = null, next = null, prev = null) {
+  async _createNode(isLeaf, keys, values, leaf = isLeaf, parent = null, next = null, prev = null) {
     const id = await this._createNodeId(isLeaf);
     const node = {
       id,
@@ -1848,40 +1963,37 @@ var BPTreeAsyncBase = class extends BPTree {
       next,
       prev
     };
-    this._nodeCreateBuffer.set(id, node);
+    await this.bufferForNodeCreate(node);
     return node;
   }
   async _deleteEntry(node, key, value) {
     if (!node.leaf) {
+      let keyIndex = -1;
       for (let i = 0, len = node.keys.length; i < len; i++) {
-        const nKey = node.keys[i];
-        if (nKey === key) {
-          node.keys.splice(i, 1);
-          this.bufferForNodeUpdate(node);
+        if (node.keys[i] === key) {
+          keyIndex = i;
           break;
         }
       }
-      for (let i = 0, len = node.values.length; i < len; i++) {
-        const nValue = node.values[i];
-        if (this.comparator.isSame(value, nValue)) {
-          node.values.splice(i, 1);
-          this.bufferForNodeUpdate(node);
-          break;
-        }
+      if (keyIndex !== -1) {
+        node.keys.splice(keyIndex, 1);
+        const valueIndex = keyIndex > 0 ? keyIndex - 1 : 0;
+        node.values.splice(valueIndex, 1);
+        await this.bufferForNodeUpdate(node);
       }
     }
     if (this.rootId === node.id && node.keys.length === 1 && !node.leaf) {
       const keys = node.keys;
-      this.bufferForNodeDelete(node);
+      await this.bufferForNodeDelete(node);
       const newRoot = await this.getNode(keys[0]);
       this.rootId = newRoot.id;
       newRoot.parent = null;
       this.strategy.head.root = this.rootId;
-      this.bufferForNodeUpdate(newRoot);
+      await this.bufferForNodeUpdate(newRoot);
       return;
     } else if (this.rootId === node.id) {
       const root = await this.getNode(this.rootId);
-      this.bufferForNodeUpdate(root);
+      await this.bufferForNodeUpdate(root);
       return;
     } else if (node.keys.length < Math.ceil(this.order / 2) && !node.leaf || node.values.length < Math.ceil((this.order - 1) / 2) && node.leaf) {
       if (node.parent === null) {
@@ -1942,7 +2054,7 @@ var BPTreeAsyncBase = class extends BPTree {
           if (pointer.next) {
             const n = await this.getNode(pointer.next);
             n.prev = pointer.id;
-            this.bufferForNodeUpdate(n);
+            await this.bufferForNodeUpdate(n);
           }
         }
         pointer.values.push(...node.values);
@@ -1951,12 +2063,12 @@ var BPTreeAsyncBase = class extends BPTree {
           for (const key2 of keys) {
             const n = await this.getNode(key2);
             n.parent = pointer.id;
-            this.bufferForNodeUpdate(n);
+            await this.bufferForNodeUpdate(n);
           }
         }
         await this._deleteEntry(await this.getNode(node.parent), node.id, guess);
-        this.bufferForNodeUpdate(pointer);
-        this.bufferForNodeDelete(node);
+        await this.bufferForNodeUpdate(pointer);
+        await this.bufferForNodeDelete(node);
       } else {
         if (isPredecessor) {
           let pointerPm;
@@ -1967,13 +2079,10 @@ var BPTreeAsyncBase = class extends BPTree {
             node.keys = [pointerPm, ...node.keys];
             node.values = [guess, ...node.values];
             parentNode = await this.getNode(node.parent);
-            for (let i = 0, len = parentNode.values.length; i < len; i++) {
-              const nValue = parentNode.values[i];
-              if (this.comparator.isSame(guess, nValue)) {
-                parentNode.values[i] = pointerKm;
-                this.bufferForNodeUpdate(parentNode);
-                break;
-              }
+            const nodeIndex = parentNode.keys.indexOf(node.id);
+            if (nodeIndex > 0) {
+              parentNode.values[nodeIndex - 1] = pointerKm;
+              await this.bufferForNodeUpdate(parentNode);
             }
           } else {
             pointerPm = pointer.keys.splice(-1)[0];
@@ -1981,17 +2090,14 @@ var BPTreeAsyncBase = class extends BPTree {
             node.keys = [pointerPm, ...node.keys];
             node.values = [pointerKm, ...node.values];
             parentNode = await this.getNode(node.parent);
-            for (let i = 0, len = parentNode.values.length; i < len; i++) {
-              const nValue = parentNode.values[i];
-              if (this.comparator.isSame(guess, nValue)) {
-                parentNode.values[i] = pointerKm;
-                this.bufferForNodeUpdate(parentNode);
-                break;
-              }
+            const nodeIndex = parentNode.keys.indexOf(node.id);
+            if (nodeIndex > 0) {
+              parentNode.values[nodeIndex - 1] = pointerKm;
+              await this.bufferForNodeUpdate(parentNode);
             }
           }
-          this.bufferForNodeUpdate(node);
-          this.bufferForNodeUpdate(pointer);
+          await this.bufferForNodeUpdate(node);
+          await this.bufferForNodeUpdate(pointer);
         } else {
           let pointerP0;
           let pointerK0;
@@ -2001,13 +2107,10 @@ var BPTreeAsyncBase = class extends BPTree {
             node.keys = [...node.keys, pointerP0];
             node.values = [...node.values, guess];
             parentNode = await this.getNode(node.parent);
-            for (let i = 0, len = parentNode.values.length; i < len; i++) {
-              const nValue = parentNode.values[i];
-              if (this.comparator.isSame(guess, nValue)) {
-                parentNode.values[i] = pointerK0;
-                this.bufferForNodeUpdate(parentNode);
-                break;
-              }
+            const pointerIndex = parentNode.keys.indexOf(pointer.id);
+            if (pointerIndex > 0) {
+              parentNode.values[pointerIndex - 1] = pointerK0;
+              await this.bufferForNodeUpdate(parentNode);
             }
           } else {
             pointerP0 = pointer.keys.splice(0, 1)[0];
@@ -2015,24 +2118,21 @@ var BPTreeAsyncBase = class extends BPTree {
             node.keys = [...node.keys, pointerP0];
             node.values = [...node.values, pointerK0];
             parentNode = await this.getNode(node.parent);
-            for (let i = 0, len = parentNode.values.length; i < len; i++) {
-              const nValue = parentNode.values[i];
-              if (this.comparator.isSame(guess, nValue)) {
-                parentNode.values[i] = pointer.values[0];
-                this.bufferForNodeUpdate(parentNode);
-                break;
-              }
+            const pointerIndex = parentNode.keys.indexOf(pointer.id);
+            if (pointerIndex > 0) {
+              parentNode.values[pointerIndex - 1] = pointer.values[0];
+              await this.bufferForNodeUpdate(parentNode);
             }
           }
-          this.bufferForNodeUpdate(node);
-          this.bufferForNodeUpdate(pointer);
+          await this.bufferForNodeUpdate(node);
+          await this.bufferForNodeUpdate(pointer);
         }
         if (!pointer.leaf) {
           const keys = pointer.keys;
           for (const key2 of keys) {
             const n = await this.getNode(key2);
             n.parent = pointer.id;
-            this.bufferForNodeUpdate(n);
+            await this.bufferForNodeUpdate(n);
           }
         }
         if (!node.leaf) {
@@ -2040,7 +2140,7 @@ var BPTreeAsyncBase = class extends BPTree {
           for (const key2 of keys) {
             const n = await this.getNode(key2);
             n.parent = node.id;
-            this.bufferForNodeUpdate(n);
+            await this.bufferForNodeUpdate(n);
           }
         }
         if (!parentNode.leaf) {
@@ -2048,10 +2148,12 @@ var BPTreeAsyncBase = class extends BPTree {
           for (const key2 of keys) {
             const n = await this.getNode(key2);
             n.parent = parentNode.id;
-            this.bufferForNodeUpdate(n);
+            await this.bufferForNodeUpdate(n);
           }
         }
       }
+    } else {
+      await this.bufferForNodeUpdate(node);
     }
   }
   async _insertInParent(node, value, pointer) {
@@ -2062,43 +2164,39 @@ var BPTreeAsyncBase = class extends BPTree {
       node.parent = root.id;
       pointer.parent = root.id;
       if (pointer.leaf) {
-        node.next = pointer.id;
-        pointer.prev = node.id;
+        const nNode = node;
+        nNode.next = pointer.id;
+        const nPointer = pointer;
+        nPointer.prev = node.id;
       }
-      this.bufferForNodeUpdate(node);
-      this.bufferForNodeUpdate(pointer);
+      await this.bufferForNodeUpdate(node);
+      await this.bufferForNodeUpdate(pointer);
       return;
     }
     const parentNode = await this.getNode(node.parent);
-    let insertIndex = 0;
-    for (let i = 0; i < parentNode.values.length; i++) {
-      if (this.comparator.asc(value, parentNode.values[i]) > 0) {
-        insertIndex = i + 1;
-      } else {
-        break;
-      }
+    const nodeIndex = parentNode.keys.indexOf(node.id);
+    if (nodeIndex === -1) {
+      throw new Error(`Node ${node.id} not found in parent ${parentNode.id}`);
     }
+    const insertIndex = nodeIndex;
     parentNode.values.splice(insertIndex, 0, value);
     parentNode.keys.splice(insertIndex + 1, 0, pointer.id);
     pointer.parent = parentNode.id;
     if (pointer.leaf) {
-      const leftSiblingId = parentNode.keys[insertIndex];
-      const rightSiblingId = parentNode.keys[insertIndex + 2];
-      if (leftSiblingId) {
-        const leftSibling = await this.getNode(leftSiblingId);
-        pointer.prev = leftSibling.id;
-        pointer.next = leftSibling.next;
-        leftSibling.next = pointer.id;
-        this.bufferForNodeUpdate(leftSibling);
-      }
-      if (rightSiblingId) {
-        const rightSibling = await this.getNode(rightSiblingId);
-        rightSibling.prev = pointer.id;
-        this.bufferForNodeUpdate(rightSibling);
-      }
-    }
-    this.bufferForNodeUpdate(parentNode);
-    this.bufferForNodeUpdate(pointer);
+      const leftSibling = node;
+      const oldNextId = leftSibling.next;
+      pointer.prev = leftSibling.id;
+      pointer.next = oldNextId;
+      leftSibling.next = pointer.id;
+      await this.bufferForNodeUpdate(leftSibling);
+      if (oldNextId) {
+        const oldNext = await this.getNode(oldNextId);
+        oldNext.prev = pointer.id;
+        await this.bufferForNodeUpdate(oldNext);
+      }
+    }
+    await this.bufferForNodeUpdate(parentNode);
+    await this.bufferForNodeUpdate(pointer);
     if (parentNode.keys.length > this.order) {
       const parentPointer = await this._createNode(false, [], []);
       parentPointer.parent = parentNode.parent;
@@ -2111,18 +2209,19 @@ var BPTreeAsyncBase = class extends BPTree {
       for (const k of parentNode.keys) {
         const n = await this.getNode(k);
         n.parent = parentNode.id;
-        this.bufferForNodeUpdate(n);
+        await this.bufferForNodeUpdate(n);
       }
       for (const k of parentPointer.keys) {
         const n = await this.getNode(k);
         n.parent = parentPointer.id;
-        this.bufferForNodeUpdate(n);
+        await this.bufferForNodeUpdate(n);
       }
       await this._insertInParent(parentNode, midValue, parentPointer);
-      this.bufferForNodeUpdate(parentNode);
+      await this.bufferForNodeUpdate(parentNode);
     }
   }
   async init() {
+    this.clear();
     const head = await this.strategy.readHead();
     if (head === null) {
       this.order = this.strategy.order;
@@ -2153,18 +2252,35 @@ var BPTreeAsyncBase = class extends BPTree {
   }
   async insertableNode(value) {
     let node = await this.getNode(this.rootId);
+    if (node.parent !== null) {
+      node.parent = null;
+      await this.bufferForNodeUpdate(node);
+    }
     while (!node.leaf) {
+      const parentId = node.id;
       for (let i = 0, len = node.values.length; i < len; i++) {
         const nValue = node.values[i];
         const k = node.keys;
         if (this.comparator.isSame(value, nValue)) {
           node = await this.getNode(node.keys[i + 1]);
+          if (node.parent !== parentId) {
+            node.parent = parentId;
+            await this.bufferForNodeUpdate(node);
+          }
           break;
         } else if (this.comparator.isLower(value, nValue)) {
           node = await this.getNode(node.keys[i]);
+          if (node.parent !== parentId) {
+            node.parent = parentId;
+            await this.bufferForNodeUpdate(node);
+          }
           break;
         } else if (i + 1 === node.values.length) {
           node = await this.getNode(node.keys[i + 1]);
+          if (node.parent !== parentId) {
+            node.parent = parentId;
+            await this.bufferForNodeUpdate(node);
+          }
           break;
         }
       }
@@ -2173,18 +2289,35 @@ var BPTreeAsyncBase = class extends BPTree {
   }
   async insertableNodeByPrimary(value) {
     let node = await this.getNode(this.rootId);
+    if (node.parent !== null) {
+      node.parent = null;
+      await this.bufferForNodeUpdate(node);
+    }
     while (!node.leaf) {
+      const parentId = node.id;
       for (let i = 0, len = node.values.length; i < len; i++) {
         const nValue = node.values[i];
         const k = node.keys;
         if (this.comparator.isPrimarySame(value, nValue)) {
           node = await this.getNode(node.keys[i]);
+          if (node.parent !== parentId) {
+            node.parent = parentId;
+            await this.bufferForNodeUpdate(node);
+          }
           break;
         } else if (this.comparator.isPrimaryLower(value, nValue)) {
           node = await this.getNode(node.keys[i]);
+          if (node.parent !== parentId) {
+            node.parent = parentId;
+            await this.bufferForNodeUpdate(node);
+          }
           break;
         } else if (i + 1 === node.values.length) {
           node = await this.getNode(node.keys[i + 1]);
+          if (node.parent !== parentId) {
+            node.parent = parentId;
+            await this.bufferForNodeUpdate(node);
+          }
           break;
         }
       }
@@ -2193,16 +2326,29 @@ var BPTreeAsyncBase = class extends BPTree {
   }
   async insertableRightestNodeByPrimary(value) {
     let node = await this.getNode(this.rootId);
+    if (node.parent !== null) {
+      node.parent = null;
+      await this.bufferForNodeUpdate(node);
+    }
     while (!node.leaf) {
+      const parentId = node.id;
       for (let i = 0, len = node.values.length; i < len; i++) {
         const nValue = node.values[i];
         const k = node.keys;
         if (this.comparator.isPrimaryLower(value, nValue)) {
           node = await this.getNode(node.keys[i]);
+          if (node.parent !== parentId) {
+            node.parent = parentId;
+            await this.bufferForNodeUpdate(node);
+          }
           break;
         }
         if (i + 1 === node.values.length) {
           node = await this.getNode(node.keys[i + 1]);
+          if (node.parent !== parentId) {
+            node.parent = parentId;
+            await this.bufferForNodeUpdate(node);
+          }
           break;
         }
       }
@@ -2237,17 +2383,35 @@ var BPTreeAsyncBase = class extends BPTree {
   }
   async leftestNode() {
     let node = await this.getNode(this.rootId);
+    if (node.parent !== null) {
+      node.parent = null;
+      await this.bufferForNodeUpdate(node);
+    }
     while (!node.leaf) {
+      const parentId = node.id;
       const keys = node.keys;
       node = await this.getNode(node.keys[0]);
+      if (node.parent !== parentId) {
+        node.parent = parentId;
+        await this.bufferForNodeUpdate(node);
+      }
     }
     return node;
   }
   async rightestNode() {
     let node = await this.getNode(this.rootId);
+    if (node.parent !== null) {
+      node.parent = null;
+      await this.bufferForNodeUpdate(node);
+    }
     while (!node.leaf) {
+      const parentId = node.id;
       const keys = node.keys;
       node = await this.getNode(node.keys[node.keys.length - 1]);
+      if (node.parent !== parentId) {
+        node.parent = parentId;
+        await this.bufferForNodeUpdate(node);
+      }
     }
     return node;
   }
@@ -2407,7 +2571,7 @@ var BPTreeAsyncBase = class extends BPTree {
   async insert(key, value) {
     await this.writeLock(async () => {
       const before = await this.insertableNode(value);
-      this._insertAtLeaf(before, key, value);
+      await this._insertAtLeaf(before, key, value);
       if (before.values.length === this.order) {
         const after = await this._createNode(
           true,
@@ -2424,7 +2588,7 @@ var BPTreeAsyncBase = class extends BPTree {
         before.values = before.values.slice(0, mid + 1);
         before.keys = before.keys.slice(0, mid + 1);
         await this._insertInParent(before, after.values[0], after);
-        this.bufferForNodeUpdate(before);
+        await this.bufferForNodeUpdate(before);
       }
       await this.commitHeadBuffer();
       await this.commitNodeCreateBuffer();
@@ -2447,11 +2611,13 @@ var BPTreeAsyncBase = class extends BPTree {
               node.values.splice(i, 1);
             }
             await this._deleteEntry(node, key, value);
+            await this.bufferForNodeUpdate(node);
             break;
           }
         }
       }
       await this.commitHeadBuffer();
+      await this.commitNodeCreateBuffer();
       await this.commitNodeUpdateBuffer();
       await this.commitNodeDeleteBuffer();
     });
@@ -2577,23 +2743,37 @@ var BPTreeAsyncTransaction = class extends BPTreeAsyncBase {
   realBaseTree;
   realBaseStrategy;
   txNodes = /* @__PURE__ */ new Map();
-  dirtyIds = /* @__PURE__ */ new Set();
-  createdInTx = /* @__PURE__ */ new Set();
+  dirtyIds;
+  createdInTx;
+  deletedIds;
   initialRootId;
   transactionRootId;
   constructor(baseTree) {
     super(baseTree.strategy, baseTree.comparator, baseTree.option);
     this.realBaseTree = baseTree;
     this.realBaseStrategy = baseTree.strategy;
+    this.order = baseTree.getOrder();
     this.initialRootId = "";
     this.transactionRootId = "";
+    this.dirtyIds = /* @__PURE__ */ new Set();
+    this.createdInTx = /* @__PURE__ */ new Set();
+    this.deletedIds = /* @__PURE__ */ new Set();
   }
   /**
    * Initializes the transaction by capturing the current state of the tree.
    */
   async initTransaction() {
     const head = await this.realBaseStrategy.readHead();
-    this.initialRootId = head?.root ?? this.realBaseTree.rootId;
+    if (head) {
+      this.order = head.order;
+      this.initialRootId = head.root;
+    } else {
+      this.initialRootId = this.realBaseTree.getRootId();
+    }
+    if (!this.initialRootId) {
+      const root = await this._createNode(true, [], [], true);
+      this.initialRootId = root.id;
+    }
     this.transactionRootId = this.initialRootId;
     this.rootId = this.transactionRootId;
     const snapshotStrategy = new BPTreeAsyncSnapshotStrategy(this.realBaseStrategy, this.initialRootId);
@@ -2601,34 +2781,76 @@ var BPTreeAsyncTransaction = class extends BPTreeAsyncBase {
     this.txNodes.clear();
     this.dirtyIds.clear();
     this.createdInTx.clear();
+    this.deletedIds.clear();
   }
   async getNode(id) {
     if (this.txNodes.has(id)) {
       return this.txNodes.get(id);
     }
+    if (this.deletedIds.has(id)) {
+      throw new Error(`The tree attempted to reference deleted node '${id}'`);
+    }
     const baseNode = await this.realBaseStrategy.read(id);
     const clone = JSON.parse(JSON.stringify(baseNode));
     this.txNodes.set(id, clone);
     return clone;
   }
   async bufferForNodeUpdate(node) {
+    if (this.dirtyIds.has(node.id) && this.txNodes.has(node.id) && node._p) {
+      this.txNodes.set(node.id, node);
+      return;
+    }
+    node._p = true;
     this.txNodes.set(node.id, node);
     this.dirtyIds.add(node.id);
+    if (node.leaf) {
+      if (node.next && !this.dirtyIds.has(node.next) && !this.deletedIds.has(node.next)) {
+        try {
+          await this.bufferForNodeUpdate(await this.getNode(node.next));
+        } catch (e) {
+        }
+      }
+      if (node.prev && !this.dirtyIds.has(node.prev) && !this.deletedIds.has(node.prev)) {
+        try {
+          await this.bufferForNodeUpdate(await this.getNode(node.prev));
+        } catch (e) {
+        }
+      }
+    }
     await this.markPathDirty(node);
+    delete node._p;
   }
   async bufferForNodeCreate(node) {
     this.txNodes.set(node.id, node);
     this.dirtyIds.add(node.id);
     this.createdInTx.add(node.id);
+    if (node.leaf) {
+      if (node.next && !this.dirtyIds.has(node.next) && !this.deletedIds.has(node.next)) {
+        try {
+          await this.bufferForNodeUpdate(await this.getNode(node.next));
+        } catch (e) {
+        }
+      }
+      if (node.prev && !this.dirtyIds.has(node.prev) && !this.deletedIds.has(node.prev)) {
+        try {
+          await this.bufferForNodeUpdate(await this.getNode(node.prev));
+        } catch (e) {
+        }
+      }
+    }
     await this.markPathDirty(node);
   }
   async bufferForNodeDelete(node) {
     this.txNodes.delete(node.id);
     this.dirtyIds.add(node.id);
+    this.deletedIds.add(node.id);
   }
   async markPathDirty(node) {
     let curr = node;
     while (curr.parent) {
+      if (this.deletedIds.has(curr.parent)) {
+        break;
+      }
       if (this.dirtyIds.has(curr.parent) && this.txNodes.has(curr.parent)) {
         break;
       }
@@ -2640,13 +2862,13 @@ var BPTreeAsyncTransaction = class extends BPTreeAsyncBase {
       this.transactionRootId = curr.id;
     }
   }
-  async _createNode(isLeaf, keys, values, leaf = false, parent = null, next = null, prev = null) {
-    const id = await this.realBaseStrategy.id(isLeaf);
+  async _createNode(isLeaf, keys, values, leaf = isLeaf, parent = null, next = null, prev = null) {
+    const id = await this.strategy.id(isLeaf);
     const node = {
       id,
       keys,
       values,
-      leaf: isLeaf,
+      leaf,
       parent,
       next,
       prev
@@ -2704,9 +2926,9 @@ var BPTreeAsyncTransaction = class extends BPTreeAsyncBase {
       finalNodes.push(node);
       newCreatedIds.push(newId);
     }
-    let newRootId = this.transactionRootId;
-    if (idMapping.has(this.transactionRootId)) {
-      newRootId = idMapping.get(this.transactionRootId);
+    let newRootId = this.rootId;
+    if (idMapping.has(this.rootId)) {
+      newRootId = idMapping.get(this.rootId);
     }
     for (const node of finalNodes) {
       await this.realBaseStrategy.write(node.id, node);