serializable-bptree 8.3.4 → 8.4.0

package/dist/cjs/index.cjs

@@ -1608,28 +1608,28 @@ var BPTreeTransaction = class _BPTreeTransaction {
   searchConfigs = {
     gt: {
       asc: {
-        start: (tx, v) => tx.insertableRightestNodeByPrimary(v[0]),
+        start: (tx, v) => tx.findUpperBoundLeaf(v[0]),
         end: () => null,
         direction: 1,
         earlyTerminate: false
       },
       desc: {
         start: (tx) => tx.rightestNode(),
-        end: (tx, v) => tx.insertableEndNode(v[0], -1),
+        end: (tx, v) => tx.findOuterBoundaryLeaf(v[0], -1),
         direction: -1,
         earlyTerminate: true
       }
     },
     gte: {
       asc: {
-        start: (tx, v) => tx.insertableNodeByPrimary(v[0]),
+        start: (tx, v) => tx.findLowerBoundLeaf(v[0]),
         end: () => null,
         direction: 1,
         earlyTerminate: false
       },
       desc: {
         start: (tx) => tx.rightestNode(),
-        end: (tx, v) => tx.insertableEndNode(v[0], -1),
+        end: (tx, v) => tx.findOuterBoundaryLeaf(v[0], -1),
         direction: -1,
         earlyTerminate: true
       }
@@ -1637,12 +1637,12 @@ var BPTreeTransaction = class _BPTreeTransaction {
     lt: {
       asc: {
         start: (tx) => tx.leftestNode(),
-        end: (tx, v) => tx.insertableEndNode(v[0], 1),
+        end: (tx, v) => tx.findOuterBoundaryLeaf(v[0], 1),
         direction: 1,
         earlyTerminate: true
       },
       desc: {
-        start: (tx, v) => tx.insertableNodeByPrimary(v[0]),
+        start: (tx, v) => tx.findLowerBoundLeaf(v[0]),
         end: () => null,
         direction: -1,
         earlyTerminate: false
@@ -1651,12 +1651,12 @@ var BPTreeTransaction = class _BPTreeTransaction {
     lte: {
       asc: {
         start: (tx) => tx.leftestNode(),
-        end: (tx, v) => tx.insertableEndNode(v[0], 1),
+        end: (tx, v) => tx.findOuterBoundaryLeaf(v[0], 1),
         direction: 1,
         earlyTerminate: true
       },
       desc: {
-        start: (tx, v) => tx.insertableRightestNodeByPrimary(v[0]),
+        start: (tx, v) => tx.findUpperBoundLeaf(v[0]),
         end: () => null,
         direction: -1,
         earlyTerminate: false
@@ -1664,14 +1664,14 @@ var BPTreeTransaction = class _BPTreeTransaction {
     },
     equal: {
       asc: {
-        start: (tx, v) => tx.insertableNodeByPrimary(v[0]),
-        end: (tx, v) => tx.insertableEndNode(v[0], 1),
+        start: (tx, v) => tx.findLowerBoundLeaf(v[0]),
+        end: (tx, v) => tx.findOuterBoundaryLeaf(v[0], 1),
         direction: 1,
         earlyTerminate: true
       },
       desc: {
-        start: (tx, v) => tx.insertableEndNode(v[0], 1),
-        end: (tx, v) => tx.insertableEndNode(v[0], -1),
+        start: (tx, v) => tx.findOuterBoundaryLeaf(v[0], 1),
+        end: (tx, v) => tx.findOuterBoundaryLeaf(v[0], -1),
         direction: -1,
         earlyTerminate: true
       }
@@ -1692,42 +1692,42 @@ var BPTreeTransaction = class _BPTreeTransaction {
     },
     or: {
       asc: {
-        start: (tx, v) => tx.insertableNodeByPrimary(tx.lowestValue(v)),
-        end: (tx, v) => tx.insertableEndNode(tx.highestValue(v), 1),
+        start: (tx, v) => tx.findLowerBoundLeaf(tx.lowestValue(v)),
+        end: (tx, v) => tx.findOuterBoundaryLeaf(tx.highestValue(v), 1),
         direction: 1,
         earlyTerminate: false
       },
       desc: {
-        start: (tx, v) => tx.insertableEndNode(tx.highestValue(v), 1),
-        end: (tx, v) => tx.insertableEndNode(tx.lowestValue(v), -1),
+        start: (tx, v) => tx.findOuterBoundaryLeaf(tx.highestValue(v), 1),
+        end: (tx, v) => tx.findOuterBoundaryLeaf(tx.lowestValue(v), -1),
         direction: -1,
         earlyTerminate: false
       }
     },
     primaryGt: {
       asc: {
-        start: (tx, v) => tx.insertableRightestNodeByPrimary(v[0]),
+        start: (tx, v) => tx.findUpperBoundLeaf(v[0]),
         end: () => null,
         direction: 1,
         earlyTerminate: false
       },
       desc: {
         start: (tx) => tx.rightestNode(),
-        end: (tx, v) => tx.insertableEndNode(v[0], -1),
+        end: (tx, v) => tx.findOuterBoundaryLeaf(v[0], -1),
         direction: -1,
         earlyTerminate: true
       }
     },
     primaryGte: {
       asc: {
-        start: (tx, v) => tx.insertableNodeByPrimary(v[0]),
+        start: (tx, v) => tx.findLowerBoundLeaf(v[0]),
         end: () => null,
         direction: 1,
         earlyTerminate: false
       },
       desc: {
         start: (tx) => tx.rightestNode(),
-        end: (tx, v) => tx.insertableEndNode(v[0], -1),
+        end: (tx, v) => tx.findOuterBoundaryLeaf(v[0], -1),
         direction: -1,
         earlyTerminate: true
       }
@@ -1735,12 +1735,12 @@ var BPTreeTransaction = class _BPTreeTransaction {
     primaryLt: {
       asc: {
         start: (tx) => tx.leftestNode(),
-        end: (tx, v) => tx.insertableEndNode(v[0], 1),
+        end: (tx, v) => tx.findOuterBoundaryLeaf(v[0], 1),
         direction: 1,
         earlyTerminate: true
       },
       desc: {
-        start: (tx, v) => tx.insertableNodeByPrimary(v[0]),
+        start: (tx, v) => tx.findLowerBoundLeaf(v[0]),
         end: () => null,
         direction: -1,
         earlyTerminate: false
@@ -1749,12 +1749,12 @@ var BPTreeTransaction = class _BPTreeTransaction {
     primaryLte: {
       asc: {
         start: (tx) => tx.leftestNode(),
-        end: (tx, v) => tx.insertableEndNode(v[0], 1),
+        end: (tx, v) => tx.findOuterBoundaryLeaf(v[0], 1),
         direction: 1,
         earlyTerminate: true
       },
       desc: {
-        start: (tx, v) => tx.insertableRightestNodeByPrimary(v[0]),
+        start: (tx, v) => tx.findUpperBoundLeaf(v[0]),
         end: () => null,
         direction: -1,
         earlyTerminate: false
@@ -1762,14 +1762,14 @@ var BPTreeTransaction = class _BPTreeTransaction {
     },
     primaryEqual: {
       asc: {
-        start: (tx, v) => tx.insertableNodeByPrimary(v[0]),
-        end: (tx, v) => tx.insertableRightestEndNodeByPrimary(v[0]),
+        start: (tx, v) => tx.findLowerBoundLeaf(v[0]),
+        end: (tx, v) => tx.findOuterBoundaryLeaf(v[0], 1),
         direction: 1,
         earlyTerminate: true
       },
       desc: {
-        start: (tx, v) => tx.insertableRightestNodeByPrimary(v[0]),
-        end: (tx, v) => tx.insertableEndNode(v[0], -1),
+        start: (tx, v) => tx.findUpperBoundLeaf(v[0]),
+        end: (tx, v) => tx.findOuterBoundaryLeaf(v[0], -1),
         direction: -1,
         earlyTerminate: true
       }
@@ -1790,14 +1790,14 @@ var BPTreeTransaction = class _BPTreeTransaction {
     },
     primaryOr: {
       asc: {
-        start: (tx, v) => tx.insertableNodeByPrimary(tx.lowestPrimaryValue(v)),
-        end: (tx, v) => tx.insertableRightestEndNodeByPrimary(tx.highestPrimaryValue(v)),
+        start: (tx, v) => tx.findLowerBoundLeaf(tx.lowestPrimaryValue(v)),
+        end: (tx, v) => tx.findOuterBoundaryLeaf(tx.highestPrimaryValue(v), 1),
         direction: 1,
         earlyTerminate: false
       },
       desc: {
-        start: (tx, v) => tx.insertableRightestNodeByPrimary(tx.highestPrimaryValue(v)),
-        end: (tx, v) => tx.insertableEndNode(tx.lowestPrimaryValue(v), -1),
+        start: (tx, v) => tx.findUpperBoundLeaf(tx.highestPrimaryValue(v)),
+        end: (tx, v) => tx.findOuterBoundaryLeaf(tx.lowestPrimaryValue(v), -1),
         direction: -1,
         earlyTerminate: false
       }
@@ -1924,30 +1924,22 @@ var BPTreeTransaction = class _BPTreeTransaction {
    */
   _insertValueIntoLeaf(leaf, key, value) {
     if (leaf.values.length) {
-      for (let i = 0, len = leaf.values.length; i < len; i++) {
-        const nValue = leaf.values[i];
-        if (this.comparator.isSame(value, nValue)) {
-          if (leaf.keys[i].includes(key)) {
-            return false;
-          }
-          leaf.keys[i].push(key);
-          return true;
-        } else if (this.comparator.isLower(value, nValue)) {
-          leaf.values.splice(i, 0, value);
-          leaf.keys.splice(i, 0, [key]);
-          return true;
-        } else if (i + 1 === leaf.values.length) {
-          leaf.values.push(value);
-          leaf.keys.push([key]);
-          return true;
+      const { index, found } = this._binarySearchValues(leaf.values, value);
+      if (found) {
+        if (leaf.keys[index].includes(key)) {
+          return false;
         }
+        leaf.keys[index].push(key);
+        return true;
       }
+      leaf.values.splice(index, 0, value);
+      leaf.keys.splice(index, 0, [key]);
+      return true;
     } else {
       leaf.values = [value];
       leaf.keys = [[key]];
       return true;
     }
-    return false;
   }
   _cloneNode(node) {
     return JSON.parse(JSON.stringify(node));
@@ -1969,17 +1961,19 @@ var BPTreeTransaction = class _BPTreeTransaction {
     let endKey = null;
     let startValues = [];
     let endValues = [];
-    for (const key of startCandidates) {
+    for (let i = 0, len = startCandidates.length; i < len; i++) {
+      const key = startCandidates[i];
       if (key in condition) {
         startKey = key;
-        startValues = this.ensureValues(condition[key]);
+        startValues = _BPTreeTransaction._multiValueKeys.includes(key) ? this.ensureValues(condition[key]) : [condition[key]];
         break;
       }
     }
-    for (const key of endCandidates) {
+    for (let i = 0, len = endCandidates.length; i < len; i++) {
+      const key = endCandidates[i];
       if (key in condition) {
         endKey = key;
-        endValues = this.ensureValues(condition[key]);
+        endValues = _BPTreeTransaction._multiValueKeys.includes(key) ? this.ensureValues(condition[key]) : [condition[key]];
         break;
       }
     }
@@ -2009,6 +2003,11 @@ var BPTreeTransaction = class _BPTreeTransaction {
     "primaryOr",
     "or"
   ];
+  // Condition keys that accept multiple values (V[]) rather than a single value (V)
+  static _multiValueKeys = [
+    "or",
+    "primaryOr"
+  ];
   constructor(rootTx, mvccRoot, mvcc, strategy, comparator, option) {
     this.rootTx = rootTx === null ? this : rootTx;
     this.mvccRoot = mvccRoot;
@@ -2233,12 +2232,8 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
       const midValue = parentNode.values[mid];
       parentNode.values = parentNode.values.slice(0, mid);
       parentNode.keys = parentNode.keys.slice(0, mid + 1);
-      for (const k of parentNode.keys) {
-        const n = this._cloneNode(this.getNode(k));
-        n.parent = parentNode.id;
-        this._updateNode(n);
-      }
-      for (const k of newSiblingNodeRecursive.keys) {
+      for (let i = 0, len = newSiblingNodeRecursive.keys.length; i < len; i++) {
+        const k = newSiblingNodeRecursive.keys[i];
         const n = this._cloneNode(this.getNode(k));
         n.parent = newSiblingNodeRecursive.id;
         this._updateNode(n);
@@ -2247,7 +2242,7 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
       this._insertInParent(parentNode, midValue, newSiblingNodeRecursive);
     }
   }
-  insertableNode(value) {
+  locateLeaf(value) {
     let node = this.getNode(this.rootId);
     while (!node.leaf) {
       const { index } = this._binarySearchValues(node.values, value, false, true);
@@ -2255,7 +2250,7 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
     }
     return node;
   }
-  insertableNodeByPrimary(value) {
+  findLowerBoundLeaf(value) {
     let node = this.getNode(this.rootId);
     while (!node.leaf) {
       const { index } = this._binarySearchValues(node.values, value, true, false);
@@ -2263,7 +2258,7 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
     }
     return node;
   }
-  insertableRightestNodeByPrimary(value) {
+  findUpperBoundLeaf(value) {
     let node = this.getNode(this.rootId);
     while (!node.leaf) {
       const { index } = this._binarySearchValues(node.values, value, true, true);
@@ -2271,15 +2266,8 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
     }
     return node;
   }
-  insertableRightestEndNodeByPrimary(value) {
-    const node = this.insertableRightestNodeByPrimary(value);
-    if (!node.next) {
-      return null;
-    }
-    return this.getNode(node.next);
-  }
-  insertableEndNode(value, direction) {
-    const insertableNode = direction === -1 ? this.insertableNodeByPrimary(value) : this.insertableRightestNodeByPrimary(value);
+  findOuterBoundaryLeaf(value, direction) {
+    const insertableNode = direction === -1 ? this.findLowerBoundLeaf(value) : this.findUpperBoundLeaf(value);
     let key;
     switch (direction) {
       case -1:
@@ -2327,7 +2315,7 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
         for (let i = 0; i < len; i++) {
           const nValue = node.values[i];
           const keys = node.keys[i];
-          for (let j = 0, kLen = keys.length; j < kLen; j++) {
+          for (let j = 0, len2 = keys.length; j < len2; j++) {
             yield [keys[j], nValue];
           }
         }
@@ -2391,7 +2379,7 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
     }
   }
   exists(key, value) {
-    const node = this.insertableNode(value);
+    const node = this.locateLeaf(value);
     const { index, found } = this._binarySearchValues(node.values, value);
     if (found) {
       const keys = node.keys[index];
@@ -2406,7 +2394,7 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
     while (true) {
       for (let i = 0, len = node.values.length; i < len; i++) {
         const keys = node.keys[i];
-        for (let j = 0, kLen = keys.length; j < kLen; j++) {
+        for (let j = 0, len2 = keys.length; j < len2; j++) {
           if (keys[j] === key) {
             return node.values[i];
           }
@@ -2488,7 +2476,7 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
     return map;
   }
   insert(key, value) {
-    let before = this.insertableNode(value);
+    let before = this.locateLeaf(value);
     before = this._insertAtLeaf(before, key, value);
     if (before.values.length === this.order) {
       let after = this._createNode(
@@ -2515,8 +2503,16 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
     const sorted = [...entries].sort((a, b) => this.comparator.asc(a[1], b[1]));
     let currentLeaf = null;
     let modified = false;
-    for (const [key, value] of sorted) {
-      const targetLeaf = this.insertableNode(value);
+    let cachedLeafId = null;
+    let cachedLeafMaxValue = null;
+    for (let i = 0, len = sorted.length; i < len; i++) {
+      const [key, value] = sorted[i];
+      let targetLeaf;
+      if (cachedLeafId !== null && cachedLeafMaxValue !== null && currentLeaf !== null && (this.comparator.isLower(value, cachedLeafMaxValue) || this.comparator.isSame(value, cachedLeafMaxValue))) {
+        targetLeaf = currentLeaf;
+      } else {
+        targetLeaf = this.locateLeaf(value);
+      }
       if (currentLeaf !== null && currentLeaf.id === targetLeaf.id) {
       } else {
         if (currentLeaf !== null && modified) {
@@ -2525,8 +2521,10 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
         currentLeaf = this._cloneNode(targetLeaf);
         modified = false;
       }
+      cachedLeafId = currentLeaf.id;
       const changed = this._insertValueIntoLeaf(currentLeaf, key, value);
       modified = modified || changed;
+      cachedLeafMaxValue = currentLeaf.values[currentLeaf.values.length - 1];
       if (currentLeaf.values.length === this.order) {
         this._updateNode(currentLeaf);
         let after = this._createNode(
@@ -2547,6 +2545,8 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
         this._updateNode(after);
         this._insertInParent(currentLeaf, after.values[0], after);
         currentLeaf = null;
+        cachedLeafId = null;
+        cachedLeafMaxValue = null;
         modified = false;
       }
     }
@@ -2554,6 +2554,85 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
       this._updateNode(currentLeaf);
     }
   }
+  bulkLoad(entries) {
+    if (entries.length === 0) return;
+    const root = this.getNode(this.rootId);
+    if (!root.leaf || root.values.length > 0) {
+      throw new Error("bulkLoad can only be called on an empty tree. Use batchInsert for non-empty trees.");
+    }
+    const sorted = [...entries].sort((a, b) => this.comparator.asc(a[1], b[1]));
+    const grouped = [];
+    for (let i = 0, len = sorted.length; i < len; i++) {
+      const [key, value] = sorted[i];
+      const last = grouped[grouped.length - 1];
+      if (last && this.comparator.isSame(last.value, value)) {
+        if (!last.keys.includes(key)) {
+          last.keys.push(key);
+        }
+      } else {
+        grouped.push({ keys: [key], value });
+      }
+    }
+    this._deleteNode(root);
+    const maxLeafSize = this.order - 1;
+    const leaves = [];
+    for (let i = 0, len = grouped.length; i < len; i += maxLeafSize) {
+      const chunk = grouped.slice(i, i + maxLeafSize);
+      const leafKeys = chunk.map((g) => g.keys);
+      const leafValues = chunk.map((g) => g.value);
+      const leaf = this._createNode(
+        true,
+        leafKeys,
+        leafValues,
+        null,
+        null,
+        null
+      );
+      leaves.push(leaf);
+    }
+    for (let i = 0, len = leaves.length; i < len; i++) {
+      if (i > 0) {
+        leaves[i].prev = leaves[i - 1].id;
+      }
+      if (i < len - 1) {
+        leaves[i].next = leaves[i + 1].id;
+      }
+      this._updateNode(leaves[i]);
+    }
+    let currentLevel = leaves;
+    while (currentLevel.length > 1) {
+      const nextLevel = [];
+      for (let i = 0, len = currentLevel.length; i < len; i += this.order) {
+        const children = currentLevel.slice(i, i + this.order);
+        const childIds = children.map((c) => c.id);
+        const separators = [];
+        for (let j = 1, len2 = children.length; j < len2; j++) {
+          separators.push(children[j].values[0]);
+        }
+        const internalNode = this._createNode(
+          false,
+          childIds,
+          separators,
+          null,
+          null,
+          null
+        );
+        for (let j = 0, len2 = children.length; j < len2; j++) {
+          const child = children[j];
+          child.parent = internalNode.id;
+          this._updateNode(child);
+        }
+        nextLevel.push(internalNode);
+      }
+      currentLevel = nextLevel;
+    }
+    const newRoot = currentLevel[0];
+    this._writeHead({
+      root: newRoot.id,
+      order: this.order,
+      data: this.strategy.head.data
+    });
+  }
   _deleteEntry(node, key) {
     if (!node.leaf) {
       let keyIndex = -1;
@@ -2657,7 +2736,8 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
         siblingNode.values.push(...node.values);
         if (!siblingNode.leaf) {
           const keys = siblingNode.keys;
-          for (const key2 of keys) {
+          for (let i = 0, len = keys.length; i < len; i++) {
+            const key2 = keys[i];
             const node2 = this._cloneNode(this.getNode(key2));
             node2.parent = siblingNode.id;
             this._updateNode(node2);
@@ -2725,21 +2805,24 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
           this._updateNode(siblingNode);
         }
         if (!siblingNode.leaf) {
-          for (const key2 of siblingNode.keys) {
+          for (let i = 0, len = siblingNode.keys.length; i < len; i++) {
+            const key2 = siblingNode.keys[i];
             const n = this._cloneNode(this.getNode(key2));
             n.parent = siblingNode.id;
             this._updateNode(n);
           }
         }
         if (!node.leaf) {
-          for (const key2 of node.keys) {
+          for (let i = 0, len = node.keys.length; i < len; i++) {
+            const key2 = node.keys[i];
             const n = this._cloneNode(this.getNode(key2));
             n.parent = node.id;
             this._updateNode(n);
           }
         }
         if (!parentNode.leaf) {
-          for (const key2 of parentNode.keys) {
+          for (let i = 0, len = parentNode.keys.length; i < len; i++) {
+            const key2 = parentNode.keys[i];
             const n = this._cloneNode(this.getNode(key2));
             n.parent = parentNode.id;
             this._updateNode(n);
@@ -2758,7 +2841,7 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
     if (value === void 0) {
       return;
     }
-    let node = this.insertableNodeByPrimary(value);
+    let node = this.findLowerBoundLeaf(value);
     let found = false;
     while (true) {
       let i = node.values.length;
@@ -2917,6 +3000,14 @@ var BPTreeSync = class extends BPTreeSyncTransaction {
       throw new Error(`Transaction failed: ${result.error || "Commit failed due to conflict"}`);
     }
   }
+  bulkLoad(entries) {
+    const tx = this.createTransaction();
+    tx.bulkLoad(entries);
+    const result = tx.commit();
+    if (!result.success) {
+      throw new Error(`Transaction failed: ${result.error || "Commit failed due to conflict"}`);
+    }
+  }
 };
 
 // node_modules/ryoiki/dist/esm/index.mjs
@@ -3334,12 +3425,8 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
       const midValue = parentNode.values[mid];
       parentNode.values = parentNode.values.slice(0, mid);
       parentNode.keys = parentNode.keys.slice(0, mid + 1);
-      for (const k of parentNode.keys) {
-        const n = this._cloneNode(await this.getNode(k));
-        n.parent = parentNode.id;
-        await this._updateNode(n);
-      }
-      for (const k of newSiblingNodeRecursive.keys) {
+      for (let i = 0, len = newSiblingNodeRecursive.keys.length; i < len; i++) {
+        const k = newSiblingNodeRecursive.keys[i];
         const n = this._cloneNode(await this.getNode(k));
         n.parent = newSiblingNodeRecursive.id;
         await this._updateNode(n);
@@ -3348,7 +3435,7 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
       await this._insertInParent(parentNode, midValue, newSiblingNodeRecursive);
     }
   }
-  async insertableNode(value) {
+  async locateLeaf(value) {
     let node = await this.getNode(this.rootId);
     while (!node.leaf) {
       const { index } = this._binarySearchValues(node.values, value, false, true);
@@ -3356,7 +3443,7 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
     }
     return node;
   }
-  async insertableNodeByPrimary(value) {
+  async findLowerBoundLeaf(value) {
     let node = await this.getNode(this.rootId);
     while (!node.leaf) {
       const { index } = this._binarySearchValues(node.values, value, true, false);
@@ -3364,7 +3451,7 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
     }
     return node;
   }
-  async insertableRightestNodeByPrimary(value) {
+  async findUpperBoundLeaf(value) {
     let node = await this.getNode(this.rootId);
     while (!node.leaf) {
       const { index } = this._binarySearchValues(node.values, value, true, true);
@@ -3372,15 +3459,8 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
     }
     return node;
   }
-  async insertableRightestEndNodeByPrimary(value) {
-    const node = await this.insertableRightestNodeByPrimary(value);
-    if (!node.next) {
-      return null;
-    }
-    return await this.getNode(node.next);
-  }
-  async insertableEndNode(value, direction) {
-    const insertableNode = direction === -1 ? await this.insertableNodeByPrimary(value) : await this.insertableRightestNodeByPrimary(value);
+  async findOuterBoundaryLeaf(value, direction) {
+    const insertableNode = direction === -1 ? await this.findLowerBoundLeaf(value) : await this.findUpperBoundLeaf(value);
     let key;
     switch (direction) {
       case -1:
@@ -3438,7 +3518,7 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
         for (let i = 0; i < len; i++) {
           const nValue = node.values[i];
           const keys = node.keys[i];
-          for (let j = 0, kLen = keys.length; j < kLen; j++) {
+          for (let j = 0, len2 = keys.length; j < len2; j++) {
             yield [keys[j], nValue];
           }
         }
@@ -3501,7 +3581,7 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
     }
   }
   async exists(key, value) {
-    const node = await this.insertableNode(value);
+    const node = await this.locateLeaf(value);
     const { index, found } = this._binarySearchValues(node.values, value);
     if (found) {
       const keys = node.keys[index];
@@ -3516,7 +3596,7 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
     while (true) {
       for (let i = 0, len = node.values.length; i < len; i++) {
         const keys = node.keys[i];
-        for (let j = 0, kLen = keys.length; j < kLen; j++) {
+        for (let j = 0, len2 = keys.length; j < len2; j++) {
           if (keys[j] === key) {
             return node.values[i];
           }
@@ -3599,7 +3679,7 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
   }
   async insert(key, value) {
     return this.writeLock(0, async () => {
-      let before = await this.insertableNode(value);
+      let before = await this.locateLeaf(value);
       before = await this._insertAtLeaf(before, key, value);
       if (before.values.length === this.order) {
         let after = await this._createNode(
@@ -3628,8 +3708,16 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
       const sorted = [...entries].sort((a, b) => this.comparator.asc(a[1], b[1]));
       let currentLeaf = null;
       let modified = false;
-      for (const [key, value] of sorted) {
-        const targetLeaf = await this.insertableNode(value);
+      let cachedLeafId = null;
+      let cachedLeafMaxValue = null;
+      for (let i = 0, len = sorted.length; i < len; i++) {
+        const [key, value] = sorted[i];
+        let targetLeaf;
+        if (cachedLeafId !== null && cachedLeafMaxValue !== null && currentLeaf !== null && (this.comparator.isLower(value, cachedLeafMaxValue) || this.comparator.isSame(value, cachedLeafMaxValue))) {
+          targetLeaf = currentLeaf;
+        } else {
+          targetLeaf = await this.locateLeaf(value);
+        }
         if (currentLeaf !== null && currentLeaf.id === targetLeaf.id) {
         } else {
           if (currentLeaf !== null && modified) {
@@ -3638,8 +3726,10 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
           currentLeaf = this._cloneNode(targetLeaf);
           modified = false;
         }
+        cachedLeafId = currentLeaf.id;
         const changed = this._insertValueIntoLeaf(currentLeaf, key, value);
         modified = modified || changed;
+        cachedLeafMaxValue = currentLeaf.values[currentLeaf.values.length - 1];
         if (currentLeaf.values.length === this.order) {
           await this._updateNode(currentLeaf);
           let after = await this._createNode(
@@ -3660,6 +3750,8 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
           await this._updateNode(after);
           await this._insertInParent(currentLeaf, after.values[0], after);
           currentLeaf = null;
+          cachedLeafId = null;
+          cachedLeafMaxValue = null;
           modified = false;
         }
       }
@@ -3668,6 +3760,87 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
       }
     });
   }
+  async bulkLoad(entries) {
+    if (entries.length === 0) return;
+    return this.writeLock(0, async () => {
+      const root = await this.getNode(this.rootId);
+      if (!root.leaf || root.values.length > 0) {
+        throw new Error("bulkLoad can only be called on an empty tree. Use batchInsert for non-empty trees.");
+      }
+      const sorted = [...entries].sort((a, b) => this.comparator.asc(a[1], b[1]));
+      const grouped = [];
+      for (let i = 0, len = sorted.length; i < len; i++) {
+        const [key, value] = sorted[i];
+        const last = grouped[grouped.length - 1];
+        if (last && this.comparator.isSame(last.value, value)) {
+          if (!last.keys.includes(key)) {
+            last.keys.push(key);
+          }
+        } else {
+          grouped.push({ keys: [key], value });
+        }
+      }
+      await this._deleteNode(root);
+      const maxLeafSize = this.order - 1;
+      const leaves = [];
+      for (let i = 0, len = grouped.length; i < len; i += maxLeafSize) {
+        const chunk = grouped.slice(i, i + maxLeafSize);
+        const leafKeys = chunk.map((g) => g.keys);
+        const leafValues = chunk.map((g) => g.value);
+        const leaf = await this._createNode(
+          true,
+          leafKeys,
+          leafValues,
+          null,
+          null,
+          null
+        );
+        leaves.push(leaf);
+      }
+      for (let i = 0, len = leaves.length; i < len; i++) {
+        if (i > 0) {
+          leaves[i].prev = leaves[i - 1].id;
+        }
+        if (i < len - 1) {
+          leaves[i].next = leaves[i + 1].id;
+        }
+        await this._updateNode(leaves[i]);
+      }
+      let currentLevel = leaves;
+      while (currentLevel.length > 1) {
+        const nextLevel = [];
+        for (let i = 0, len = currentLevel.length; i < len; i += this.order) {
+          const children = currentLevel.slice(i, i + this.order);
+          const childIds = children.map((c) => c.id);
+          const separators = [];
+          for (let j = 1, len2 = children.length; j < len2; j++) {
+            separators.push(children[j].values[0]);
+          }
+          const internalNode = await this._createNode(
+            false,
+            childIds,
+            separators,
+            null,
+            null,
+            null
+          );
+          for (let j = 0, len2 = children.length; j < len2; j++) {
+            const child = children[j];
+            child.parent = internalNode.id;
+            await this._updateNode(child);
+          }
+          nextLevel.push(internalNode);
+        }
+        currentLevel = nextLevel;
+      }
+      const newRoot = currentLevel[0];
+      await this._writeHead({
+        root: newRoot.id,
+        order: this.order,
+        data: this.strategy.head.data
+      });
+    });
+  }
   async _deleteEntry(node, key) {
     if (!node.leaf) {
       let keyIndex = -1;
@@ -3771,7 +3944,8 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
         siblingNode.values.push(...node.values);
         if (!siblingNode.leaf) {
           const keys = siblingNode.keys;
-          for (const key2 of keys) {
+          for (let i = 0, len = keys.length; i < len; i++) {
+            const key2 = keys[i];
             const node2 = this._cloneNode(await this.getNode(key2));
             node2.parent = siblingNode.id;
             await this._updateNode(node2);
@@ -3839,21 +4013,24 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
           await this._updateNode(siblingNode);
         }
         if (!siblingNode.leaf) {
-          for (const key2 of siblingNode.keys) {
+          for (let i = 0, len = siblingNode.keys.length; i < len; i++) {
+            const key2 = siblingNode.keys[i];
             const n = this._cloneNode(await this.getNode(key2));
             n.parent = siblingNode.id;
             await this._updateNode(n);
           }
         }
         if (!node.leaf) {
-          for (const key2 of node.keys) {
+          for (let i = 0, len = node.keys.length; i < len; i++) {
+            const key2 = node.keys[i];
             const n = this._cloneNode(await this.getNode(key2));
             n.parent = node.id;
             await this._updateNode(n);
           }
         }
         if (!parentNode.leaf) {
-          for (const key2 of parentNode.keys) {
+          for (let i = 0, len = parentNode.keys.length; i < len; i++) {
+            const key2 = parentNode.keys[i];
             const n = this._cloneNode(await this.getNode(key2));
             n.parent = parentNode.id;
             await this._updateNode(n);
@@ -3873,7 +4050,7 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
       if (value === void 0) {
         return;
       }
-      let node = await this.insertableNodeByPrimary(value);
+      let node = await this.findLowerBoundLeaf(value);
       let found = false;
       while (true) {
         let i = node.values.length;
@@ -4039,6 +4216,16 @@ var BPTreeAsync = class extends BPTreeAsyncTransaction {
       }
     });
   }
+  async bulkLoad(entries) {
+    return this.writeLock(1, async () => {
+      const tx = await this.createTransaction();
+      await tx.bulkLoad(entries);
+      const result = await tx.commit();
+      if (!result.success) {
+        throw new Error(`Transaction failed: ${result.error || "Commit failed due to conflict"}`);
+      }
+    });
+  }
 };
 
 // src/base/SerializeStrategy.ts