serializable-bptree 8.3.5 → 8.4.1

package/README.md

@@ -84,6 +84,7 @@ Additionally, this library supports asynchronous operations and rule-based query
 - **Async/Sync Support**: Provides both synchronous and asynchronous APIs.
 - **Query Optimization**: Rule-based optimizer to choose the best index for complex queries.
 - **TypeScript**: Fully typed for a better developer experience.
+- **Auto Rollback**: Automatically cleans up internal memory buffers on commit failures, preventing memory leaks without manual intervention.
 
 ## How to use
 

package/dist/cjs/index.cjs

@@ -413,11 +413,7 @@ var MVCCTransaction = class {
    */
   rollback() {
     const { created, updated, deleted } = this.getResultEntries();
-    this.writeBuffer.clear();
-    this.deleteBuffer.clear();
-    this.createdKeys.clear();
-    this.deletedValues.clear();
-    this.originallyExisted.clear();
+    this._cleanupAll();
     this.committed = true;
     if (this.root !== this) {
       this.root.activeTransactions.delete(this);
@@ -453,6 +449,19 @@ var MVCCTransaction = class {
     }
     return Array.from(conflicts);
   }
+  /**
+   * Cleans up all buffers and history.
+   * This method is called by the commit method.
+   */
+  _cleanupAll() {
+    this.writeBuffer.clear();
+    this.deleteBuffer.clear();
+    this.createdKeys.clear();
+    this.deletedValues.clear();
+    this.originallyExisted.clear();
+    this.keyVersions.clear();
+    this.bufferHistory.clear();
+  }
   /**
    * Cleans up both deletedCache and versionIndex based on minActiveVersion.
    * Root transactions call this after commit to reclaim memory.
@@ -644,6 +653,7 @@ var SyncMVCCTransaction = class _SyncMVCCTransaction extends MVCCTransaction {
     if (this.parent) {
       const failure = this.parent._merge(this);
       if (failure) {
+        this.rollback();
         return {
           label,
           success: false,
@@ -654,11 +664,13 @@ var SyncMVCCTransaction = class _SyncMVCCTransaction extends MVCCTransaction {
           deleted
         };
       }
+      this._cleanupAll();
       this.committed = true;
     } else {
       if (this.writeBuffer.size > 0 || this.deleteBuffer.size > 0) {
         const failure = this._merge(this);
         if (failure) {
+          this.rollback();
           return {
             label,
             success: false,
@@ -669,13 +681,7 @@ var SyncMVCCTransaction = class _SyncMVCCTransaction extends MVCCTransaction {
             deleted: []
           };
         }
-        this.writeBuffer.clear();
-        this.deleteBuffer.clear();
-        this.createdKeys.clear();
-        this.deletedValues.clear();
-        this.originallyExisted.clear();
-        this.keyVersions.clear();
-        this.bufferHistory.clear();
+        this._cleanupAll();
         this.localVersion = 0;
         this.snapshotVersion = this.version;
       }
@@ -1309,6 +1315,7 @@ var AsyncMVCCTransaction = class _AsyncMVCCTransaction extends MVCCTransaction {
     if (this.parent) {
       const failure = await this.parent._merge(this);
       if (failure) {
+        this.rollback();
         return {
           label,
           success: false,
@@ -1319,11 +1326,13 @@ var AsyncMVCCTransaction = class _AsyncMVCCTransaction extends MVCCTransaction {
           deleted
         };
       }
+      this._cleanupAll();
       this.committed = true;
     } else {
       if (this.writeBuffer.size > 0 || this.deleteBuffer.size > 0) {
         const failure = await this._merge(this);
         if (failure) {
+          this.rollback();
           return {
             label,
             success: false,
@@ -1334,13 +1343,7 @@ var AsyncMVCCTransaction = class _AsyncMVCCTransaction extends MVCCTransaction {
             deleted: []
           };
         }
-        this.writeBuffer.clear();
-        this.deleteBuffer.clear();
-        this.createdKeys.clear();
-        this.deletedValues.clear();
-        this.originallyExisted.clear();
-        this.keyVersions.clear();
-        this.bufferHistory.clear();
+        this._cleanupAll();
         this.localVersion = 0;
         this.snapshotVersion = this.version;
       }
@@ -1924,30 +1927,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));
@@ -2240,12 +2235,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);
@@ -2327,7 +2318,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];
           }
         }
@@ -2406,7 +2397,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];
           }
@@ -2515,8 +2506,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.locateLeaf(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 +2524,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 +2548,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 +2557,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 +2739,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 +2808,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);
@@ -2816,8 +2902,12 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
         result = this.rootTx.commit(label);
         if (result.success) {
           this.rootTx.rootId = this.rootId;
+        } else {
+          this.mvcc.rollback();
         }
       }
+    } else {
+      this.mvcc.rollback();
     }
     return result;
   }
@@ -2917,6 +3007,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 +3432,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);
@@ -3431,7 +3525,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];
           }
         }
@@ -3509,7 +3603,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];
           }
@@ -3621,8 +3715,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.locateLeaf(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) {
@@ -3631,8 +3733,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(
@@ -3653,6 +3757,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;
         }
       }
@@ -3661,6 +3767,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;
@@ -3764,7 +3951,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);
@@ -3832,21 +4020,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);
@@ -3925,8 +4116,12 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
         result = await this.rootTx.commit(label);
         if (result.success) {
           this.rootTx.rootId = this.rootId;
+        } else {
+          this.mvcc.rollback();
         }
       }
+    } else {
+      this.mvcc.rollback();
     }
     return result;
   }
@@ -4032,6 +4227,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

package/dist/esm/index.mjs

@@ -377,11 +377,7 @@ var MVCCTransaction = class {
    */
   rollback() {
     const { created, updated, deleted } = this.getResultEntries();
-    this.writeBuffer.clear();
-    this.deleteBuffer.clear();
-    this.createdKeys.clear();
-    this.deletedValues.clear();
-    this.originallyExisted.clear();
+    this._cleanupAll();
     this.committed = true;
     if (this.root !== this) {
       this.root.activeTransactions.delete(this);
@@ -417,6 +413,19 @@ var MVCCTransaction = class {
     }
     return Array.from(conflicts);
   }
+  /**
+   * Cleans up all buffers and history.
+   * This method is called by the commit method.
+   */
+  _cleanupAll() {
+    this.writeBuffer.clear();
+    this.deleteBuffer.clear();
+    this.createdKeys.clear();
+    this.deletedValues.clear();
+    this.originallyExisted.clear();
+    this.keyVersions.clear();
+    this.bufferHistory.clear();
+  }
   /**
    * Cleans up both deletedCache and versionIndex based on minActiveVersion.
    * Root transactions call this after commit to reclaim memory.
@@ -608,6 +617,7 @@ var SyncMVCCTransaction = class _SyncMVCCTransaction extends MVCCTransaction {
     if (this.parent) {
       const failure = this.parent._merge(this);
       if (failure) {
+        this.rollback();
         return {
           label,
           success: false,
@@ -618,11 +628,13 @@ var SyncMVCCTransaction = class _SyncMVCCTransaction extends MVCCTransaction {
           deleted
         };
       }
+      this._cleanupAll();
       this.committed = true;
     } else {
       if (this.writeBuffer.size > 0 || this.deleteBuffer.size > 0) {
         const failure = this._merge(this);
         if (failure) {
+          this.rollback();
           return {
             label,
             success: false,
@@ -633,13 +645,7 @@ var SyncMVCCTransaction = class _SyncMVCCTransaction extends MVCCTransaction {
             deleted: []
           };
         }
-        this.writeBuffer.clear();
-        this.deleteBuffer.clear();
-        this.createdKeys.clear();
-        this.deletedValues.clear();
-        this.originallyExisted.clear();
-        this.keyVersions.clear();
-        this.bufferHistory.clear();
+        this._cleanupAll();
         this.localVersion = 0;
         this.snapshotVersion = this.version;
       }
@@ -1273,6 +1279,7 @@ var AsyncMVCCTransaction = class _AsyncMVCCTransaction extends MVCCTransaction {
     if (this.parent) {
       const failure = await this.parent._merge(this);
       if (failure) {
+        this.rollback();
         return {
           label,
           success: false,
@@ -1283,11 +1290,13 @@ var AsyncMVCCTransaction = class _AsyncMVCCTransaction extends MVCCTransaction {
           deleted
         };
       }
+      this._cleanupAll();
       this.committed = true;
     } else {
       if (this.writeBuffer.size > 0 || this.deleteBuffer.size > 0) {
         const failure = await this._merge(this);
         if (failure) {
+          this.rollback();
           return {
             label,
             success: false,
@@ -1298,13 +1307,7 @@ var AsyncMVCCTransaction = class _AsyncMVCCTransaction extends MVCCTransaction {
             deleted: []
           };
         }
-        this.writeBuffer.clear();
-        this.deleteBuffer.clear();
-        this.createdKeys.clear();
-        this.deletedValues.clear();
-        this.originallyExisted.clear();
-        this.keyVersions.clear();
-        this.bufferHistory.clear();
+        this._cleanupAll();
         this.localVersion = 0;
         this.snapshotVersion = this.version;
       }
@@ -1888,30 +1891,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));
@@ -2204,12 +2199,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);
@@ -2291,7 +2282,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];
           }
         }
@@ -2370,7 +2361,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];
           }
@@ -2479,8 +2470,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.locateLeaf(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) {
@@ -2489,8 +2488,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(
@@ -2511,6 +2512,8 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
         this._updateNode(after);
         this._insertInParent(currentLeaf, after.values[0], after);
         currentLeaf = null;
+        cachedLeafId = null;
+        cachedLeafMaxValue = null;
         modified = false;
       }
     }
@@ -2518,6 +2521,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;
@@ -2621,7 +2703,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);
@@ -2689,21 +2772,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);
@@ -2780,8 +2866,12 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
         result = this.rootTx.commit(label);
         if (result.success) {
           this.rootTx.rootId = this.rootId;
+        } else {
+          this.mvcc.rollback();
         }
       }
+    } else {
+      this.mvcc.rollback();
     }
     return result;
   }
@@ -2881,6 +2971,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
@@ -3298,12 +3396,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);
@@ -3395,7 +3489,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];
           }
         }
@@ -3473,7 +3567,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];
           }
@@ -3585,8 +3679,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.locateLeaf(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) {
@@ -3595,8 +3697,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(
@@ -3617,6 +3721,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;
         }
       }
@@ -3625,6 +3731,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;
@@ -3728,7 +3915,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);
@@ -3796,21 +3984,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);
@@ -3889,8 +4080,12 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
         result = await this.rootTx.commit(label);
         if (result.success) {
           this.rootTx.rootId = this.rootId;
+        } else {
+          this.mvcc.rollback();
         }
       }
+    } else {
+      this.mvcc.rollback();
     }
     return result;
   }
@@ -3996,6 +4191,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

package/dist/types/BPTreeAsync.d.ts

@@ -12,4 +12,5 @@ export declare class BPTreeAsync<K, V> extends BPTreeAsyncTransaction<K, V> {
     insert(key: K, value: V): Promise<void>;
     delete(key: K, value?: V): Promise<void>;
     batchInsert(entries: [K, V][]): Promise<void>;
+    bulkLoad(entries: [K, V][]): Promise<void>;
 }

package/dist/types/BPTreeSync.d.ts

@@ -12,4 +12,5 @@ export declare class BPTreeSync<K, V> extends BPTreeSyncTransaction<K, V> {
     insert(key: K, value: V): void;
     delete(key: K, value?: V): void;
     batchInsert(entries: [K, V][]): void;
+    bulkLoad(entries: [K, V][]): void;
 }

package/dist/types/base/BPTreeTransaction.d.ts

@@ -173,6 +173,18 @@ export declare abstract class BPTreeTransaction<K, V> {
      * @param entries Array of [key, value] pairs to insert.
      */
     abstract batchInsert(entries: [K, V][]): Deferred<void>;
+    /**
+     * Builds a B+Tree from scratch using bulk loading (bottom-up construction).
+     * This is significantly faster than batchInsert for initial tree construction,
+     * as it avoids top-down traversal and creates nodes directly.
+     *
+     * **Precondition**: The tree must be empty. If the tree already contains data,
+     * an error will be thrown. Use batchInsert for adding data to an existing tree.
+     *
+     * @param entries Array of [key, value] pairs to bulk load.
+     * @throws Error if the tree is not empty.
+     */
+    abstract bulkLoad(entries: [K, V][]): Deferred<void>;
     /**
      * Deletes the pair that matches the key and value.
      * @param key The key of the pair. This key must be unique.

package/dist/types/transaction/BPTreeAsyncTransaction.d.ts

@@ -42,6 +42,7 @@ export declare class BPTreeAsyncTransaction<K, V> extends BPTreeTransaction<K, V
     where(condition: BPTreeCondition<V>, options?: BPTreeSearchOption<K>): Promise<BPTreePair<K, V>>;
     insert(key: K, value: V): Promise<void>;
     batchInsert(entries: [K, V][]): Promise<void>;
+    bulkLoad(entries: [K, V][]): Promise<void>;
     protected _deleteEntry(node: BPTreeUnknownNode<K, V>, key: BPTreeNodeKey<K>): Promise<BPTreeUnknownNode<K, V>>;
     delete(key: K, value?: V): Promise<void>;
     getHeadData(): Promise<SerializableData>;

package/dist/types/transaction/BPTreeSyncTransaction.d.ts

@@ -39,6 +39,7 @@ export declare class BPTreeSyncTransaction<K, V> extends BPTreeTransaction<K, V>
     where(condition: BPTreeCondition<V>, options?: BPTreeSearchOption<K>): BPTreePair<K, V>;
     insert(key: K, value: V): void;
     batchInsert(entries: [K, V][]): void;
+    bulkLoad(entries: [K, V][]): void;
     protected _deleteEntry(node: BPTreeUnknownNode<K, V>, key: BPTreeNodeKey<K>): BPTreeUnknownNode<K, V>;
     delete(key: K, value?: V): void;
     getHeadData(): SerializableData;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "serializable-bptree",
-  "version": "8.3.5",
+  "version": "8.4.1",
   "description": "Store the B+tree flexibly, not only in-memory.",
   "types": "./dist/types/index.d.ts",
   "main": "./dist/cjs/index.cjs",
@@ -44,7 +44,7 @@
     "typescript": "^5.9.3"
   },
   "dependencies": {
-    "mvcc-api": "^1.3.5",
+    "mvcc-api": "^1.3.6",
     "ryoiki": "^1.2.0"
   }
 }