serializable-bptree 8.1.4 → 8.1.5

package/dist/cjs/index.cjs

@@ -230,6 +230,41 @@ var MVCCTransaction = class {
       });
     }
   }
+  /**
+   * BINARY SEARCH HELPER: Finds the index of the last element in the array 
+   * where item[key] <= target. Assumes the array is sorted by 'key' ascending.
+   */
+  _findLastLE(array, target, property) {
+    let left = 0;
+    let right = array.length - 1;
+    let result = -1;
+    while (left <= right) {
+      const mid = left + right >> 1;
+      if (array[mid][property] <= target) {
+        result = mid;
+        left = mid + 1;
+      } else {
+        right = mid - 1;
+      }
+    }
+    return result;
+  }
+  /**
+   * BINARY SEARCH HELPER: Finds the index of the element in the array 
+   * where item[key] === target. Assumes the array is sorted by 'key' ascending.
+   */
+  _findExact(array, target, property) {
+    let left = 0;
+    let right = array.length - 1;
+    while (left <= right) {
+      const mid = left + right >> 1;
+      const val = array[mid][property];
+      if (val === target) return mid;
+      if (val < target) left = mid + 1;
+      else right = mid - 1;
+    }
+    return -1;
+  }
   _bufferCreate(key, value, version) {
     if (version === void 0) this.localVersion++;
     const targetVersion = version ?? this.localVersion;
@@ -415,58 +450,62 @@ var SyncMVCCTransaction = class _SyncMVCCTransaction extends MVCCTransaction {
     return this._diskExists(key, this.snapshotVersion);
   }
   _existsSnapshot(key, snapshotVersion, snapshotLocalVersion) {
-    if (this.writeBuffer.has(key)) {
-      const keyModVersion = this.keyVersions.get(key);
-      if (snapshotLocalVersion === void 0 || keyModVersion <= snapshotLocalVersion) {
-        return true;
-      }
-    }
-    if (this.deleteBuffer.has(key)) {
-      const keyModVersion = this.keyVersions.get(key);
-      if (snapshotLocalVersion === void 0 || keyModVersion <= snapshotLocalVersion) {
-        return false;
-      }
-    }
-    const history = this.bufferHistory.get(key);
-    if (history && snapshotLocalVersion !== void 0) {
-      for (let i = history.length - 1; i >= 0; i--) {
-        if (history[i].version <= snapshotLocalVersion) {
-          return history[i].exists;
-        }
+    let current = this;
+    let slVer = snapshotLocalVersion;
+    while (current) {
+      if (current.writeBuffer.has(key)) {
+        const keyModVersion = current.keyVersions.get(key);
+        if (slVer === void 0 || keyModVersion <= slVer) return true;
+      }
+      if (current.deleteBuffer.has(key)) {
+        const keyModVersion = current.keyVersions.get(key);
+        if (slVer === void 0 || keyModVersion <= slVer) return false;
+      }
+      const history = current.bufferHistory.get(key);
+      if (history && slVer !== void 0) {
+        const idx = current._findLastLE(history, slVer, "version");
+        if (idx >= 0) return history[idx].exists;
+      }
+      if (current.parent) {
+        slVer = current.snapshotLocalVersion;
+        current = current.parent;
+      } else {
+        return current._diskExists(key, snapshotVersion);
       }
     }
-    if (this.parent) {
-      return this.parent._existsSnapshot(key, snapshotVersion, this.snapshotLocalVersion);
-    } else {
-      return this._diskExists(key, snapshotVersion);
-    }
+    return false;
   }
   _readSnapshot(key, snapshotVersion, snapshotLocalVersion) {
-    if (this.writeBuffer.has(key)) {
-      const keyModVersion = this.keyVersions.get(key);
-      if (snapshotLocalVersion === void 0 || keyModVersion <= snapshotLocalVersion) {
-        return this.writeBuffer.get(key);
+    let current = this;
+    let slVer = snapshotLocalVersion;
+    while (current) {
+      if (current.writeBuffer.has(key)) {
+        const keyModVersion = current.keyVersions.get(key);
+        if (slVer === void 0 || keyModVersion <= slVer) {
+          return current.writeBuffer.get(key);
+        }
       }
-    }
-    if (this.deleteBuffer.has(key)) {
-      const keyModVersion = this.keyVersions.get(key);
-      if (snapshotLocalVersion === void 0 || keyModVersion <= snapshotLocalVersion) {
-        return null;
+      if (current.deleteBuffer.has(key)) {
+        const keyModVersion = current.keyVersions.get(key);
+        if (slVer === void 0 || keyModVersion <= slVer) {
+          return null;
+        }
       }
-    }
-    const history = this.bufferHistory.get(key);
-    if (history && snapshotLocalVersion !== void 0) {
-      for (let i = history.length - 1; i >= 0; i--) {
-        if (history[i].version <= snapshotLocalVersion) {
-          return history[i].exists ? history[i].value : null;
+      const history = current.bufferHistory.get(key);
+      if (history && slVer !== void 0) {
+        const idx = current._findLastLE(history, slVer, "version");
+        if (idx >= 0) {
+          return history[idx].exists ? history[idx].value : null;
         }
       }
+      if (current.parent) {
+        slVer = current.snapshotLocalVersion;
+        current = current.parent;
+      } else {
+        return current._diskRead(key, snapshotVersion);
+      }
     }
-    if (this.parent) {
-      return this.parent._readSnapshot(key, snapshotVersion, this.snapshotLocalVersion);
-    } else {
-      return this._diskRead(key, snapshotVersion);
-    }
+    return null;
   }
   commit(label) {
     const { created, updated, deleted } = this.getResultEntries();
@@ -671,19 +710,15 @@ var SyncMVCCTransaction = class _SyncMVCCTransaction extends MVCCTransaction {
     }
     let targetVerObj = null;
     let nextVerObj = null;
-    for (const v of versions) {
-      if (v.version <= snapshotVersion) targetVerObj = v;
-      else {
-        nextVerObj = v;
-        break;
-      }
-    }
+    const idx = this._findLastLE(versions, snapshotVersion, "version");
+    if (idx >= 0) targetVerObj = versions[idx];
+    if (idx + 1 < versions.length) nextVerObj = versions[idx + 1];
     if (!targetVerObj) {
       if (nextVerObj) {
         const cached2 = this.deletedCache.get(key);
         if (cached2) {
-          const match = cached2.find((c) => c.deletedAtVersion === nextVerObj.version);
-          if (match) return match.value;
+          const cIdx = this._findExact(cached2, nextVerObj.version, "deletedAtVersion");
+          if (cIdx >= 0) return cached2[cIdx].value;
         }
       }
       return null;
@@ -701,8 +736,8 @@ var SyncMVCCTransaction = class _SyncMVCCTransaction extends MVCCTransaction {
     }
     const cached = this.deletedCache.get(key);
     if (cached) {
-      const match = cached.find((c) => c.deletedAtVersion === nextVerObj.version);
-      if (match) return match.value;
+      const cIdx = this._findExact(cached, nextVerObj.version, "deletedAtVersion");
+      if (cIdx >= 0) return cached[cIdx].value;
     }
     return null;
   }
@@ -719,19 +754,15 @@ var SyncMVCCTransaction = class _SyncMVCCTransaction extends MVCCTransaction {
     }
     let targetVerObj = null;
     let nextVerObj = null;
-    for (const v of versions) {
-      if (v.version <= snapshotVersion) targetVerObj = v;
-      else {
-        nextVerObj = v;
-        break;
-      }
-    }
+    const idx = this._findLastLE(versions, snapshotVersion, "version");
+    if (idx >= 0) targetVerObj = versions[idx];
+    if (idx + 1 < versions.length) nextVerObj = versions[idx + 1];
     if (!targetVerObj) {
       if (nextVerObj) {
         const cached = this.deletedCache.get(key);
         if (cached) {
-          const match = cached.find((c) => c.deletedAtVersion === nextVerObj.version);
-          if (match) return true;
+          const cIdx = this._findExact(cached, nextVerObj.version, "deletedAtVersion");
+          if (cIdx >= 0) return true;
         }
       }
       return false;
@@ -1084,58 +1115,62 @@ var AsyncMVCCTransaction = class _AsyncMVCCTransaction extends MVCCTransaction {
     return await this._diskExists(key, this.snapshotVersion);
   }
   async _existsSnapshot(key, snapshotVersion, snapshotLocalVersion) {
-    if (this.writeBuffer.has(key)) {
-      const keyModVersion = this.keyVersions.get(key);
-      if (snapshotLocalVersion === void 0 || keyModVersion <= snapshotLocalVersion) {
-        return true;
-      }
-    }
-    if (this.deleteBuffer.has(key)) {
-      const keyModVersion = this.keyVersions.get(key);
-      if (snapshotLocalVersion === void 0 || keyModVersion <= snapshotLocalVersion) {
-        return false;
-      }
-    }
-    const history = this.bufferHistory.get(key);
-    if (history && snapshotLocalVersion !== void 0) {
-      for (let i = history.length - 1; i >= 0; i--) {
-        if (history[i].version <= snapshotLocalVersion) {
-          return history[i].exists;
-        }
+    let current = this;
+    let slVer = snapshotLocalVersion;
+    while (current) {
+      if (current.writeBuffer.has(key)) {
+        const keyModVersion = current.keyVersions.get(key);
+        if (slVer === void 0 || keyModVersion <= slVer) return true;
+      }
+      if (current.deleteBuffer.has(key)) {
+        const keyModVersion = current.keyVersions.get(key);
+        if (slVer === void 0 || keyModVersion <= slVer) return false;
+      }
+      const history = current.bufferHistory.get(key);
+      if (history && slVer !== void 0) {
+        const idx = current._findLastLE(history, slVer, "version");
+        if (idx >= 0) return history[idx].exists;
+      }
+      if (current.parent) {
+        slVer = current.snapshotLocalVersion;
+        current = current.parent;
+      } else {
+        return await current._diskExists(key, snapshotVersion);
       }
     }
-    if (this.parent) {
-      return this.parent._existsSnapshot(key, snapshotVersion, this.snapshotLocalVersion);
-    } else {
-      return await this._diskExists(key, snapshotVersion);
-    }
+    return false;
   }
   async _readSnapshot(key, snapshotVersion, snapshotLocalVersion) {
-    if (this.writeBuffer.has(key)) {
-      const keyModVersion = this.keyVersions.get(key);
-      if (snapshotLocalVersion === void 0 || keyModVersion <= snapshotLocalVersion) {
-        return this.writeBuffer.get(key);
+    let current = this;
+    let slVer = snapshotLocalVersion;
+    while (current) {
+      if (current.writeBuffer.has(key)) {
+        const keyModVersion = current.keyVersions.get(key);
+        if (slVer === void 0 || keyModVersion <= slVer) {
+          return current.writeBuffer.get(key);
+        }
       }
-    }
-    if (this.deleteBuffer.has(key)) {
-      const keyModVersion = this.keyVersions.get(key);
-      if (snapshotLocalVersion === void 0 || keyModVersion <= snapshotLocalVersion) {
-        return null;
+      if (current.deleteBuffer.has(key)) {
+        const keyModVersion = current.keyVersions.get(key);
+        if (slVer === void 0 || keyModVersion <= slVer) {
+          return null;
+        }
       }
-    }
-    const history = this.bufferHistory.get(key);
-    if (history && snapshotLocalVersion !== void 0) {
-      for (let i = history.length - 1; i >= 0; i--) {
-        if (history[i].version <= snapshotLocalVersion) {
-          return history[i].exists ? history[i].value : null;
+      const history = current.bufferHistory.get(key);
+      if (history && slVer !== void 0) {
+        const idx = current._findLastLE(history, slVer, "version");
+        if (idx >= 0) {
+          return history[idx].exists ? history[idx].value : null;
         }
       }
+      if (current.parent) {
+        slVer = current.snapshotLocalVersion;
+        current = current.parent;
+      } else {
+        return await current._diskRead(key, snapshotVersion);
+      }
     }
-    if (this.parent) {
-      return this.parent._readSnapshot(key, snapshotVersion, this.snapshotLocalVersion);
-    } else {
-      return await this._diskRead(key, snapshotVersion);
-    }
+    return null;
   }
   async commit(label) {
     const { created, updated, deleted } = this.getResultEntries();
@@ -1343,19 +1378,15 @@ var AsyncMVCCTransaction = class _AsyncMVCCTransaction extends MVCCTransaction {
     }
     let targetVerObj = null;
     let nextVerObj = null;
-    for (const v of versions) {
-      if (v.version <= snapshotVersion) targetVerObj = v;
-      else {
-        nextVerObj = v;
-        break;
-      }
-    }
+    const idx = this._findLastLE(versions, snapshotVersion, "version");
+    if (idx >= 0) targetVerObj = versions[idx];
+    if (idx + 1 < versions.length) nextVerObj = versions[idx + 1];
     if (!targetVerObj) {
       if (nextVerObj) {
         const cached2 = this.deletedCache.get(key);
         if (cached2) {
-          const match = cached2.find((c) => c.deletedAtVersion === nextVerObj.version);
-          if (match) return match.value;
+          const cIdx = this._findExact(cached2, nextVerObj.version, "deletedAtVersion");
+          if (cIdx >= 0) return cached2[cIdx].value;
         }
       }
       return null;
@@ -1373,8 +1404,8 @@ var AsyncMVCCTransaction = class _AsyncMVCCTransaction extends MVCCTransaction {
     }
     const cached = this.deletedCache.get(key);
     if (cached) {
-      const match = cached.find((c) => c.deletedAtVersion === nextVerObj.version);
-      if (match) return match.value;
+      const cIdx = this._findExact(cached, nextVerObj.version, "deletedAtVersion");
+      if (cIdx >= 0) return cached[cIdx].value;
     }
     return null;
   }
@@ -1391,19 +1422,15 @@ var AsyncMVCCTransaction = class _AsyncMVCCTransaction extends MVCCTransaction {
     }
     let targetVerObj = null;
     let nextVerObj = null;
-    for (const v of versions) {
-      if (v.version <= snapshotVersion) targetVerObj = v;
-      else {
-        nextVerObj = v;
-        break;
-      }
-    }
+    const idx = this._findLastLE(versions, snapshotVersion, "version");
+    if (idx >= 0) targetVerObj = versions[idx];
+    if (idx + 1 < versions.length) nextVerObj = versions[idx + 1];
     if (!targetVerObj) {
       if (nextVerObj) {
         const cached = this.deletedCache.get(key);
         if (cached) {
-          const match = cached.find((c) => c.deletedAtVersion === nextVerObj.version);
-          if (match) return true;
+          const cIdx = this._findExact(cached, nextVerObj.version, "deletedAtVersion");
+          if (cIdx >= 0) return true;
         }
       }
       return false;
@@ -1799,7 +1826,6 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
   }
   _insertAtLeaf(node, key, value) {
     let leaf = node;
-    leaf = this._cloneNode(leaf);
     if (leaf.values.length) {
       for (let i = 0, len = leaf.values.length; i < len; i++) {
         const nValue = leaf.values[i];
@@ -1808,15 +1834,18 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
           if (keys.includes(key)) {
             break;
           }
-          keys.push(key);
+          leaf = this._cloneNode(leaf);
+          leaf.keys[i].push(key);
           this._updateNode(leaf);
           return leaf;
         } else if (this.comparator.isLower(value, nValue)) {
+          leaf = this._cloneNode(leaf);
           leaf.values.splice(i, 0, value);
           leaf.keys.splice(i, 0, [key]);
           this._updateNode(leaf);
           return leaf;
         } else if (i + 1 === leaf.values.length) {
+          leaf = this._cloneNode(leaf);
           leaf.values.push(value);
           leaf.keys.push([key]);
           this._updateNode(leaf);
@@ -1824,6 +1853,7 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
         }
       }
     } else {
+      leaf = this._cloneNode(leaf);
       leaf.values = [value];
       leaf.keys = [[key]];
       this._updateNode(leaf);
@@ -1831,17 +1861,17 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
     }
     return leaf;
   }
-  _insertInParent(node, value, pointer) {
-    node = this._cloneNode(node);
-    pointer = this._cloneNode(pointer);
+  _insertInParent(node, value, newSiblingNode) {
     if (this.rootId === node.id) {
-      const root = this._createNode(false, [node.id, pointer.id], [value]);
+      node = this._cloneNode(node);
+      newSiblingNode = this._cloneNode(newSiblingNode);
+      const root = this._createNode(false, [node.id, newSiblingNode.id], [value]);
       this.rootId = root.id;
       node.parent = root.id;
-      pointer.parent = root.id;
-      if (pointer.leaf) {
-        node.next = pointer.id;
-        pointer.prev = node.id;
+      newSiblingNode.parent = root.id;
+      if (newSiblingNode.leaf) {
+        node.next = newSiblingNode.id;
+        newSiblingNode.prev = node.id;
       }
       this._writeHead({
         root: root.id,
@@ -1849,7 +1879,7 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
         data: this.strategy.head.data
       });
       this._updateNode(node);
-      this._updateNode(pointer);
+      this._updateNode(newSiblingNode);
       return;
     }
     const parentNode = this._cloneNode(this.getNode(node.parent));
@@ -1858,29 +1888,30 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
       throw new Error(`Node ${node.id} not found in parent ${parentNode.id}`);
     }
     parentNode.values.splice(nodeIndex, 0, value);
-    parentNode.keys.splice(nodeIndex + 1, 0, pointer.id);
-    pointer.parent = parentNode.id;
-    if (pointer.leaf) {
-      const leftSibling = node;
+    parentNode.keys.splice(nodeIndex + 1, 0, newSiblingNode.id);
+    newSiblingNode = this._cloneNode(newSiblingNode);
+    newSiblingNode.parent = parentNode.id;
+    if (newSiblingNode.leaf) {
+      const leftSibling = this._cloneNode(node);
       const oldNextId = leftSibling.next;
-      pointer.prev = leftSibling.id;
-      pointer.next = oldNextId;
-      leftSibling.next = pointer.id;
+      newSiblingNode.prev = leftSibling.id;
+      newSiblingNode.next = oldNextId;
+      leftSibling.next = newSiblingNode.id;
       this._updateNode(leftSibling);
       if (oldNextId) {
         const oldNext = this._cloneNode(this.getNode(oldNextId));
-        oldNext.prev = pointer.id;
+        oldNext.prev = newSiblingNode.id;
         this._updateNode(oldNext);
       }
     }
     this._updateNode(parentNode);
-    this._updateNode(pointer);
+    this._updateNode(newSiblingNode);
     if (parentNode.keys.length > this.order) {
-      const parentPointer = this._createNode(false, [], []);
-      parentPointer.parent = parentNode.parent;
+      const newSiblingNodeRecursive = this._createNode(false, [], []);
+      newSiblingNodeRecursive.parent = parentNode.parent;
       const mid = Math.ceil(this.order / 2) - 1;
-      parentPointer.values = parentNode.values.slice(mid + 1);
-      parentPointer.keys = parentNode.keys.slice(mid + 1);
+      newSiblingNodeRecursive.values = parentNode.values.slice(mid + 1);
+      newSiblingNodeRecursive.keys = parentNode.keys.slice(mid + 1);
       const midValue = parentNode.values[mid];
       parentNode.values = parentNode.values.slice(0, mid);
       parentNode.keys = parentNode.keys.slice(0, mid + 1);
@@ -1889,13 +1920,13 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
         n.parent = parentNode.id;
         this._updateNode(n);
       }
-      for (const k of parentPointer.keys) {
+      for (const k of newSiblingNodeRecursive.keys) {
         const n = this._cloneNode(this.getNode(k));
-        n.parent = parentPointer.id;
+        n.parent = newSiblingNodeRecursive.id;
         this._updateNode(n);
       }
       this._updateNode(parentNode);
-      this._insertInParent(parentNode, midValue, parentPointer);
+      this._insertInParent(parentNode, midValue, newSiblingNodeRecursive);
     }
   }
   insertableNode(value) {
@@ -2186,7 +2217,6 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
     }
   }
   _deleteEntry(node, key) {
-    node = this._cloneNode(node);
     if (!node.leaf) {
       let keyIndex = -1;
       for (let i = 0, len = node.keys.length; i < len; i++) {
@@ -2196,6 +2226,7 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
         }
       }
       if (keyIndex !== -1) {
+        node = this._cloneNode(node);
         node.keys.splice(keyIndex, 1);
         const valueIndex = keyIndex > 0 ? keyIndex - 1 : 0;
         node.values.splice(valueIndex, 1);
@@ -2235,73 +2266,75 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
         const nKey = parentNode.keys[i];
         if (nKey === node.id) {
           if (i > 0) {
-            prevNode = this._cloneNode(this.getNode(parentNode.keys[i - 1]));
+            prevNode = this.getNode(parentNode.keys[i - 1]);
             prevValue = parentNode.values[i - 1];
           }
           if (i < parentNode.keys.length - 1) {
-            nextNode = this._cloneNode(this.getNode(parentNode.keys[i + 1]));
+            nextNode = this.getNode(parentNode.keys[i + 1]);
             postValue = parentNode.values[i];
           }
         }
       }
-      let pointer;
+      let siblingNode;
       let guess;
       if (prevNode === null) {
-        pointer = nextNode;
+        siblingNode = nextNode;
         guess = postValue;
       } else if (nextNode === null) {
         isPredecessor = true;
-        pointer = prevNode;
+        siblingNode = prevNode;
         guess = prevValue;
       } else {
         if (node.values.length + nextNode.values.length < this.order) {
-          pointer = nextNode;
+          siblingNode = nextNode;
           guess = postValue;
         } else {
           isPredecessor = true;
-          pointer = prevNode;
+          siblingNode = prevNode;
           guess = prevValue;
         }
       }
-      if (!pointer) {
+      if (!siblingNode) {
         return node;
       }
-      if (node.values.length + pointer.values.length < this.order) {
+      node = this._cloneNode(node);
+      siblingNode = this._cloneNode(siblingNode);
+      if (node.values.length + siblingNode.values.length < this.order) {
         if (!isPredecessor) {
-          const pTemp = pointer;
-          pointer = node;
+          const pTemp = siblingNode;
+          siblingNode = node;
           node = pTemp;
         }
-        pointer.keys.push(...node.keys);
+        siblingNode.keys.push(...node.keys);
         if (!node.leaf) {
-          pointer.values.push(guess);
+          siblingNode.values.push(guess);
         } else {
-          pointer.next = node.next;
-          if (pointer.next) {
-            const n = this._cloneNode(this.getNode(pointer.next));
-            n.prev = pointer.id;
+          siblingNode.next = node.next;
+          if (siblingNode.next) {
+            const n = this._cloneNode(this.getNode(siblingNode.next));
+            n.prev = siblingNode.id;
             this._updateNode(n);
           }
         }
-        pointer.values.push(...node.values);
-        if (!pointer.leaf) {
-          const keys = pointer.keys;
+        siblingNode.values.push(...node.values);
+        if (!siblingNode.leaf) {
+          const keys = siblingNode.keys;
           for (const key2 of keys) {
             const node2 = this._cloneNode(this.getNode(key2));
-            node2.parent = pointer.id;
+            node2.parent = siblingNode.id;
             this._updateNode(node2);
           }
         }
         this._deleteNode(node);
-        this._updateNode(pointer);
-        this._deleteEntry(this._cloneNode(this.getNode(node.parent)), node.id);
+        this._updateNode(siblingNode);
+        this._deleteEntry(this.getNode(node.parent), node.id);
       } else {
         if (isPredecessor) {
           let pointerPm;
           let pointerKm;
           if (!node.leaf) {
-            pointerPm = pointer.keys.splice(-1)[0];
-            pointerKm = pointer.values.splice(-1)[0];
+            pointerPm = siblingNode.keys.splice(-1)[0];
+            pointerKm = siblingNode.values.splice(-1)[0];
             node.keys = [pointerPm, ...node.keys];
             node.values = [guess, ...node.values];
             parentNode = this._cloneNode(this.getNode(node.parent));
@@ -2311,8 +2344,8 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
               this._updateNode(parentNode);
             }
           } else {
-            pointerPm = pointer.keys.splice(-1)[0];
-            pointerKm = pointer.values.splice(-1)[0];
+            pointerPm = siblingNode.keys.splice(-1)[0];
+            pointerKm = siblingNode.values.splice(-1)[0];
             node.keys = [pointerPm, ...node.keys];
             node.values = [pointerKm, ...node.values];
             parentNode = this._cloneNode(this.getNode(node.parent));
@@ -2323,40 +2356,40 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
             }
           }
           this._updateNode(node);
-          this._updateNode(pointer);
+          this._updateNode(siblingNode);
         } else {
           let pointerP0;
           let pointerK0;
           if (!node.leaf) {
-            pointerP0 = pointer.keys.splice(0, 1)[0];
-            pointerK0 = pointer.values.splice(0, 1)[0];
+            pointerP0 = siblingNode.keys.splice(0, 1)[0];
+            pointerK0 = siblingNode.values.splice(0, 1)[0];
             node.keys = [...node.keys, pointerP0];
             node.values = [...node.values, guess];
             parentNode = this._cloneNode(this.getNode(node.parent));
-            const pointerIndex = parentNode.keys.indexOf(pointer.id);
+            const pointerIndex = parentNode.keys.indexOf(siblingNode.id);
             if (pointerIndex > 0) {
               parentNode.values[pointerIndex - 1] = pointerK0;
               this._updateNode(parentNode);
             }
           } else {
-            pointerP0 = pointer.keys.splice(0, 1)[0];
-            pointerK0 = pointer.values.splice(0, 1)[0];
+            pointerP0 = siblingNode.keys.splice(0, 1)[0];
+            pointerK0 = siblingNode.values.splice(0, 1)[0];
             node.keys = [...node.keys, pointerP0];
             node.values = [...node.values, pointerK0];
             parentNode = this._cloneNode(this.getNode(node.parent));
-            const pointerIndex = parentNode.keys.indexOf(pointer.id);
+            const pointerIndex = parentNode.keys.indexOf(siblingNode.id);
             if (pointerIndex > 0) {
-              parentNode.values[pointerIndex - 1] = pointer.values[0];
+              parentNode.values[pointerIndex - 1] = siblingNode.values[0];
               this._updateNode(parentNode);
             }
           }
           this._updateNode(node);
-          this._updateNode(pointer);
+          this._updateNode(siblingNode);
         }
-        if (!pointer.leaf) {
-          for (const key2 of pointer.keys) {
+        if (!siblingNode.leaf) {
+          for (const key2 of siblingNode.keys) {
             const n = this._cloneNode(this.getNode(key2));
-            n.parent = pointer.id;
+            n.parent = siblingNode.id;
             this._updateNode(n);
           }
         }
@@ -2376,14 +2409,13 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
         }
       }
     } else {
-      this._updateNode(node);
+      this._updateNode(this._cloneNode(node));
     }
     return node;
   }
   delete(key, value) {
     let node = this.insertableNodeByPrimary(value);
     let found = false;
-    node = this._cloneNode(node);
     while (true) {
       let i = node.values.length;
       while (i--) {
@@ -2392,8 +2424,10 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
           const keys = node.keys[i];
           const keyIndex = keys.indexOf(key);
           if (keyIndex !== -1) {
-            keys.splice(keyIndex, 1);
-            if (keys.length === 0) {
+            node = this._cloneNode(node);
+            const freshKeys = node.keys[i];
+            freshKeys.splice(keyIndex, 1);
+            if (freshKeys.length === 0) {
               node.keys.splice(i, 1);
               node.values.splice(i, 1);
             }
@@ -2848,7 +2882,7 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
     if (this.mvcc.isDeleted(node.id)) {
       return;
     }
-    await this.mvcc.write(node.id, this._cloneNode(node));
+    await this.mvcc.write(node.id, node);
   }
   async _deleteNode(node) {
     if (this.mvcc.isDeleted(node.id)) {
@@ -2861,15 +2895,14 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
   }
   async _writeHead(head) {
     if (!await this.mvcc.exists("__HEAD__")) {
-      await this.mvcc.create("__HEAD__", this._cloneNode(head));
+      await this.mvcc.create("__HEAD__", head);
     } else {
-      await this.mvcc.write("__HEAD__", this._cloneNode(head));
+      await this.mvcc.write("__HEAD__", head);
     }
     this.rootId = head.root;
   }
   async _insertAtLeaf(node, key, value) {
     let leaf = node;
-    leaf = this._cloneNode(leaf);
     if (leaf.values.length) {
       for (let i = 0, len = leaf.values.length; i < len; i++) {
         const nValue = leaf.values[i];
@@ -2878,15 +2911,18 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
           if (keys.includes(key)) {
             break;
           }
-          keys.push(key);
+          leaf = this._cloneNode(leaf);
+          leaf.keys[i].push(key);
           await this._updateNode(leaf);
           return leaf;
         } else if (this.comparator.isLower(value, nValue)) {
+          leaf = this._cloneNode(leaf);
           leaf.values.splice(i, 0, value);
           leaf.keys.splice(i, 0, [key]);
           await this._updateNode(leaf);
           return leaf;
         } else if (i + 1 === leaf.values.length) {
+          leaf = this._cloneNode(leaf);
           leaf.values.push(value);
           leaf.keys.push([key]);
           await this._updateNode(leaf);
@@ -2894,6 +2930,7 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
         }
       }
     } else {
+      leaf = this._cloneNode(leaf);
       leaf.values = [value];
       leaf.keys = [[key]];
       await this._updateNode(leaf);
@@ -2901,17 +2938,17 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
     }
     return leaf;
   }
-  async _insertInParent(node, value, pointer) {
-    node = this._cloneNode(node);
-    pointer = this._cloneNode(pointer);
+  async _insertInParent(node, value, newSiblingNode) {
     if (this.rootId === node.id) {
-      const root = await this._createNode(false, [node.id, pointer.id], [value]);
+      node = this._cloneNode(node);
+      newSiblingNode = this._cloneNode(newSiblingNode);
+      const root = await this._createNode(false, [node.id, newSiblingNode.id], [value]);
       this.rootId = root.id;
       node.parent = root.id;
-      pointer.parent = root.id;
-      if (pointer.leaf) {
-        node.next = pointer.id;
-        pointer.prev = node.id;
+      newSiblingNode.parent = root.id;
+      if (newSiblingNode.leaf) {
+        node.next = newSiblingNode.id;
+        newSiblingNode.prev = node.id;
       }
       await this._writeHead({
         root: root.id,
@@ -2919,7 +2956,7 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
         data: this.strategy.head.data
       });
       await this._updateNode(node);
-      await this._updateNode(pointer);
+      await this._updateNode(newSiblingNode);
       return;
     }
     const parentNode = this._cloneNode(await this.getNode(node.parent));
@@ -2928,29 +2965,30 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
       throw new Error(`Node ${node.id} not found in parent ${parentNode.id}`);
     }
     parentNode.values.splice(nodeIndex, 0, value);
-    parentNode.keys.splice(nodeIndex + 1, 0, pointer.id);
-    pointer.parent = parentNode.id;
-    if (pointer.leaf) {
-      const leftSibling = node;
+    parentNode.keys.splice(nodeIndex + 1, 0, newSiblingNode.id);
+    newSiblingNode = this._cloneNode(newSiblingNode);
+    newSiblingNode.parent = parentNode.id;
+    if (newSiblingNode.leaf) {
+      const leftSibling = this._cloneNode(node);
       const oldNextId = leftSibling.next;
-      pointer.prev = leftSibling.id;
-      pointer.next = oldNextId;
-      leftSibling.next = pointer.id;
+      newSiblingNode.prev = leftSibling.id;
+      newSiblingNode.next = oldNextId;
+      leftSibling.next = newSiblingNode.id;
       await this._updateNode(leftSibling);
       if (oldNextId) {
         const oldNext = this._cloneNode(await this.getNode(oldNextId));
-        oldNext.prev = pointer.id;
+        oldNext.prev = newSiblingNode.id;
         await this._updateNode(oldNext);
       }
     }
     await this._updateNode(parentNode);
-    await this._updateNode(pointer);
+    await this._updateNode(newSiblingNode);
     if (parentNode.keys.length > this.order) {
-      const parentPointer = await this._createNode(false, [], []);
-      parentPointer.parent = parentNode.parent;
+      const newSiblingNodeRecursive = await this._createNode(false, [], []);
+      newSiblingNodeRecursive.parent = parentNode.parent;
       const mid = Math.ceil(this.order / 2) - 1;
-      parentPointer.values = parentNode.values.slice(mid + 1);
-      parentPointer.keys = parentNode.keys.slice(mid + 1);
+      newSiblingNodeRecursive.values = parentNode.values.slice(mid + 1);
+      newSiblingNodeRecursive.keys = parentNode.keys.slice(mid + 1);
       const midValue = parentNode.values[mid];
       parentNode.values = parentNode.values.slice(0, mid);
       parentNode.keys = parentNode.keys.slice(0, mid + 1);
@@ -2959,13 +2997,13 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
         n.parent = parentNode.id;
         await this._updateNode(n);
       }
-      for (const k of parentPointer.keys) {
+      for (const k of newSiblingNodeRecursive.keys) {
         const n = this._cloneNode(await this.getNode(k));
-        n.parent = parentPointer.id;
+        n.parent = newSiblingNodeRecursive.id;
         await this._updateNode(n);
       }
       await this._updateNode(parentNode);
-      await this._insertInParent(parentNode, midValue, parentPointer);
+      await this._insertInParent(parentNode, midValue, newSiblingNodeRecursive);
     }
   }
   async insertableNode(value) {
@@ -3264,7 +3302,6 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
     });
   }
   async _deleteEntry(node, key) {
-    node = this._cloneNode(node);
     if (!node.leaf) {
       let keyIndex = -1;
       for (let i = 0, len = node.keys.length; i < len; i++) {
@@ -3274,6 +3311,7 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
         }
       }
       if (keyIndex !== -1) {
+        node = this._cloneNode(node);
         node.keys.splice(keyIndex, 1);
         const valueIndex = keyIndex > 0 ? keyIndex - 1 : 0;
         node.values.splice(valueIndex, 1);
@@ -3313,73 +3351,75 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
         const nKey = parentNode.keys[i];
         if (nKey === node.id) {
           if (i > 0) {
-            prevNode = this._cloneNode(await this.getNode(parentNode.keys[i - 1]));
+            prevNode = await this.getNode(parentNode.keys[i - 1]);
             prevValue = parentNode.values[i - 1];
           }
           if (i < parentNode.keys.length - 1) {
-            nextNode = this._cloneNode(await this.getNode(parentNode.keys[i + 1]));
+            nextNode = await this.getNode(parentNode.keys[i + 1]);
             postValue = parentNode.values[i];
           }
         }
       }
-      let pointer;
+      let siblingNode;
       let guess;
       if (prevNode === null) {
-        pointer = nextNode;
+        siblingNode = nextNode;
         guess = postValue;
       } else if (nextNode === null) {
         isPredecessor = true;
-        pointer = prevNode;
+        siblingNode = prevNode;
         guess = prevValue;
       } else {
         if (node.values.length + nextNode.values.length < this.order) {
-          pointer = nextNode;
+          siblingNode = nextNode;
           guess = postValue;
         } else {
           isPredecessor = true;
-          pointer = prevNode;
+          siblingNode = prevNode;
           guess = prevValue;
         }
       }
-      if (!pointer) {
+      if (!siblingNode) {
         return node;
       }
-      if (node.values.length + pointer.values.length < this.order) {
+      node = this._cloneNode(node);
+      siblingNode = this._cloneNode(siblingNode);
+      if (node.values.length + siblingNode.values.length < this.order) {
         if (!isPredecessor) {
-          const pTemp = pointer;
-          pointer = node;
+          const pTemp = siblingNode;
+          siblingNode = node;
           node = pTemp;
         }
-        pointer.keys.push(...node.keys);
+        siblingNode.keys.push(...node.keys);
         if (!node.leaf) {
-          pointer.values.push(guess);
+          siblingNode.values.push(guess);
         } else {
-          pointer.next = node.next;
-          if (pointer.next) {
-            const n = this._cloneNode(await this.getNode(pointer.next));
-            n.prev = pointer.id;
+          siblingNode.next = node.next;
+          if (siblingNode.next) {
+            const n = this._cloneNode(await this.getNode(siblingNode.next));
+            n.prev = siblingNode.id;
             await this._updateNode(n);
           }
         }
-        pointer.values.push(...node.values);
-        if (!pointer.leaf) {
-          const keys = pointer.keys;
+        siblingNode.values.push(...node.values);
+        if (!siblingNode.leaf) {
+          const keys = siblingNode.keys;
           for (const key2 of keys) {
             const node2 = this._cloneNode(await this.getNode(key2));
-            node2.parent = pointer.id;
+            node2.parent = siblingNode.id;
             await this._updateNode(node2);
           }
         }
         this._deleteNode(node);
-        await this._updateNode(pointer);
-        await this._deleteEntry(this._cloneNode(await this.getNode(node.parent)), node.id);
+        await this._updateNode(siblingNode);
+        await this._deleteEntry(await this.getNode(node.parent), node.id);
       } else {
         if (isPredecessor) {
           let pointerPm;
           let pointerKm;
           if (!node.leaf) {
-            pointerPm = pointer.keys.splice(-1)[0];
-            pointerKm = pointer.values.splice(-1)[0];
+            pointerPm = siblingNode.keys.splice(-1)[0];
+            pointerKm = siblingNode.values.splice(-1)[0];
             node.keys = [pointerPm, ...node.keys];
             node.values = [guess, ...node.values];
             parentNode = this._cloneNode(await this.getNode(node.parent));
@@ -3389,8 +3429,8 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
               await this._updateNode(parentNode);
             }
           } else {
-            pointerPm = pointer.keys.splice(-1)[0];
-            pointerKm = pointer.values.splice(-1)[0];
+            pointerPm = siblingNode.keys.splice(-1)[0];
+            pointerKm = siblingNode.values.splice(-1)[0];
             node.keys = [pointerPm, ...node.keys];
             node.values = [pointerKm, ...node.values];
             parentNode = this._cloneNode(await this.getNode(node.parent));
@@ -3401,40 +3441,40 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
             }
           }
           await this._updateNode(node);
-          await this._updateNode(pointer);
+          await this._updateNode(siblingNode);
         } else {
           let pointerP0;
           let pointerK0;
           if (!node.leaf) {
-            pointerP0 = pointer.keys.splice(0, 1)[0];
-            pointerK0 = pointer.values.splice(0, 1)[0];
+            pointerP0 = siblingNode.keys.splice(0, 1)[0];
+            pointerK0 = siblingNode.values.splice(0, 1)[0];
             node.keys = [...node.keys, pointerP0];
             node.values = [...node.values, guess];
             parentNode = this._cloneNode(await this.getNode(node.parent));
-            const pointerIndex = parentNode.keys.indexOf(pointer.id);
+            const pointerIndex = parentNode.keys.indexOf(siblingNode.id);
             if (pointerIndex > 0) {
               parentNode.values[pointerIndex - 1] = pointerK0;
               await this._updateNode(parentNode);
             }
           } else {
-            pointerP0 = pointer.keys.splice(0, 1)[0];
-            pointerK0 = pointer.values.splice(0, 1)[0];
+            pointerP0 = siblingNode.keys.splice(0, 1)[0];
+            pointerK0 = siblingNode.values.splice(0, 1)[0];
             node.keys = [...node.keys, pointerP0];
             node.values = [...node.values, pointerK0];
             parentNode = this._cloneNode(await this.getNode(node.parent));
-            const pointerIndex = parentNode.keys.indexOf(pointer.id);
+            const pointerIndex = parentNode.keys.indexOf(siblingNode.id);
             if (pointerIndex > 0) {
-              parentNode.values[pointerIndex - 1] = pointer.values[0];
+              parentNode.values[pointerIndex - 1] = siblingNode.values[0];
               await this._updateNode(parentNode);
             }
           }
           await this._updateNode(node);
-          await this._updateNode(pointer);
+          await this._updateNode(siblingNode);
         }
-        if (!pointer.leaf) {
-          for (const key2 of pointer.keys) {
+        if (!siblingNode.leaf) {
+          for (const key2 of siblingNode.keys) {
             const n = this._cloneNode(await this.getNode(key2));
-            n.parent = pointer.id;
+            n.parent = siblingNode.id;
             await this._updateNode(n);
           }
         }
@@ -3454,16 +3494,14 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
         }
       }
     } else {
-      await this._updateNode(node);
+      await this._updateNode(this._cloneNode(node));
     }
-    await this._updateNode(node);
     return node;
   }
   async delete(key, value) {
     return this.writeLock(0, async () => {
       let node = await this.insertableNodeByPrimary(value);
       let found = false;
-      node = this._cloneNode(node);
       while (true) {
         let i = node.values.length;
         while (i--) {
@@ -3472,8 +3510,10 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
             const keys = node.keys[i];
             const keyIndex = keys.indexOf(key);
             if (keyIndex !== -1) {
-              keys.splice(keyIndex, 1);
-              if (keys.length === 0) {
+              node = this._cloneNode(node);
+              const freshKeys = node.keys[i];
+              freshKeys.splice(keyIndex, 1);
+              if (freshKeys.length === 0) {
                 node.keys.splice(i, 1);
                 node.values.splice(i, 1);
               }