serializable-bptree 8.4.2 → 9.0.1

package/dist/esm/index.mjs

@@ -192,6 +192,7 @@ var MVCCTransaction = class {
   // 트랜잭션 시작 시점에 디스크에 존재했던 키 (deleted 결과 필터링용)
   bufferHistory = /* @__PURE__ */ new Map();
   // Nested Transaction Properties
+  activeDescendantCount = 0;
   parent;
   localVersion;
   // Local version for Nested Conflict Detection
@@ -268,6 +269,7 @@ var MVCCTransaction = class {
     return this.deleteBuffer.has(key);
   }
   _recordHistory(key) {
+    if (this.activeDescendantCount === 0) return;
     const existsInWriteBuffer = this.writeBuffer.has(key);
     const existsInDeleteBuffer = this.deleteBuffer.has(key);
     const currentVer = this.keyVersions.get(key);
@@ -380,6 +382,9 @@ var MVCCTransaction = class {
     this._cleanupAll();
     this.committed = true;
     if (this.root !== this) {
+      if (this.parent) {
+        this.parent._updateActiveDescendantCount(-1);
+      }
       this.root.activeTransactions.delete(this);
     }
     return {
@@ -467,6 +472,16 @@ var MVCCTransaction = class {
       }
     }
   }
+  /**
+   * Updates the descendant count for this transaction and its ancestors.
+   * @param delta The amount to change the count by.
+   */
+  _updateActiveDescendantCount(delta) {
+    this.activeDescendantCount += delta;
+    if (this.parent) {
+      this.parent._updateActiveDescendantCount(delta);
+    }
+  }
 };
 var SyncMVCCStrategy = class extends MVCCStrategy {
 };
@@ -511,7 +526,9 @@ var SyncMVCCTransaction = class _SyncMVCCTransaction extends MVCCTransaction {
     if (this.committed) throw new Error("Transaction already committed");
     const childVersion = this.isRoot() ? this.version : this.snapshotVersion;
     const child = new _SyncMVCCTransaction(void 0, void 0, this, childVersion);
-    this.root.activeTransactions.add(child);
+    this._updateActiveDescendantCount(1);
+    const rootAny = this.root;
+    rootAny.activeTransactions.add(child);
     return child;
   }
   read(key) {
@@ -629,6 +646,7 @@ var SyncMVCCTransaction = class _SyncMVCCTransaction extends MVCCTransaction {
         };
       }
       this._cleanupAll();
+      this.parent._updateActiveDescendantCount(-1);
       this.committed = true;
     } else {
       if (this.writeBuffer.size > 0 || this.deleteBuffer.size > 0) {
@@ -1173,7 +1191,9 @@ var AsyncMVCCTransaction = class _AsyncMVCCTransaction extends MVCCTransaction {
     if (this.committed) throw new Error("Transaction already committed");
     const childVersion = this.isRoot() ? this.version : this.snapshotVersion;
     const child = new _AsyncMVCCTransaction(void 0, void 0, this, childVersion);
-    this.root.activeTransactions.add(child);
+    this._updateActiveDescendantCount(1);
+    const rootAny = this.root;
+    rootAny.activeTransactions.add(child);
     return child;
   }
   async read(key) {
@@ -1291,6 +1311,7 @@ var AsyncMVCCTransaction = class _AsyncMVCCTransaction extends MVCCTransaction {
         };
       }
       this._cleanupAll();
+      this.parent._updateActiveDescendantCount(-1);
       this.committed = true;
     } else {
       if (this.writeBuffer.size > 0 || this.deleteBuffer.size > 0) {
@@ -1530,84 +1551,120 @@ var AsyncMVCCTransaction = class _AsyncMVCCTransaction extends MVCCTransaction {
   }
 };
 
-// src/base/BPTreeTransaction.ts
-var BPTreeTransaction = class _BPTreeTransaction {
-  _cachedRegexp = /* @__PURE__ */ new Map();
-  rootTx;
-  mvccRoot;
-  mvcc;
-  strategy;
-  comparator;
-  option;
-  order;
-  rootId;
-  isInitialized = false;
-  isDestroyed = false;
-  verifierMap = {
-    gt: (nv, v) => this.comparator.isHigher(nv, v),
-    gte: (nv, v) => this.comparator.isHigher(nv, v) || this.comparator.isSame(nv, v),
-    lt: (nv, v) => this.comparator.isLower(nv, v),
-    lte: (nv, v) => this.comparator.isLower(nv, v) || this.comparator.isSame(nv, v),
-    equal: (nv, v) => this.comparator.isSame(nv, v),
-    notEqual: (nv, v) => this.comparator.isSame(nv, v) === false,
-    or: (nv, v) => this.ensureValues(v).some((v2) => this.comparator.isSame(nv, v2)),
-    primaryGt: (nv, v) => this.comparator.isPrimaryHigher(nv, v),
-    primaryGte: (nv, v) => this.comparator.isPrimaryHigher(nv, v) || this.comparator.isPrimarySame(nv, v),
-    primaryLt: (nv, v) => this.comparator.isPrimaryLower(nv, v),
-    primaryLte: (nv, v) => this.comparator.isPrimaryLower(nv, v) || this.comparator.isPrimarySame(nv, v),
-    primaryEqual: (nv, v) => this.comparator.isPrimarySame(nv, v),
-    primaryNotEqual: (nv, v) => this.comparator.isPrimarySame(nv, v) === false,
-    primaryOr: (nv, v) => this.ensureValues(v).some((v2) => this.comparator.isPrimarySame(nv, v2)),
+// src/base/BPTreeAlgorithmSync.ts
+function cloneNode(node) {
+  return JSON.parse(JSON.stringify(node));
+}
+function binarySearchValues(values, target, comparator, usePrimary = false, upperBound = false) {
+  let low = 0;
+  let high = values.length;
+  let found = false;
+  while (low < high) {
+    const mid = low + high >>> 1;
+    const cmp = usePrimary ? comparator.primaryAsc(target, values[mid]) : comparator.asc(target, values[mid]);
+    if (cmp === 0) {
+      found = true;
+      if (upperBound) low = mid + 1;
+      else high = mid;
+    } else if (cmp < 0) {
+      high = mid;
+    } else {
+      low = mid + 1;
+    }
+  }
+  return { index: low, found };
+}
+function insertValueIntoLeaf(leaf, key, value, comparator) {
+  if (leaf.values.length) {
+    const { index, found } = binarySearchValues(leaf.values, value, comparator);
+    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;
+  }
+}
+function createVerifierMap(comparator, cachedRegexp, ensureValues) {
+  return {
+    gt: (nv, v) => comparator.isHigher(nv, v),
+    gte: (nv, v) => comparator.isHigher(nv, v) || comparator.isSame(nv, v),
+    lt: (nv, v) => comparator.isLower(nv, v),
+    lte: (nv, v) => comparator.isLower(nv, v) || comparator.isSame(nv, v),
+    equal: (nv, v) => comparator.isSame(nv, v),
+    notEqual: (nv, v) => comparator.isSame(nv, v) === false,
+    or: (nv, v) => ensureValues(v).some((v2) => comparator.isSame(nv, v2)),
+    primaryGt: (nv, v) => comparator.isPrimaryHigher(nv, v),
+    primaryGte: (nv, v) => comparator.isPrimaryHigher(nv, v) || comparator.isPrimarySame(nv, v),
+    primaryLt: (nv, v) => comparator.isPrimaryLower(nv, v),
+    primaryLte: (nv, v) => comparator.isPrimaryLower(nv, v) || comparator.isPrimarySame(nv, v),
+    primaryEqual: (nv, v) => comparator.isPrimarySame(nv, v),
+    primaryNotEqual: (nv, v) => comparator.isPrimarySame(nv, v) === false,
+    primaryOr: (nv, v) => ensureValues(v).some((v2) => comparator.isPrimarySame(nv, v2)),
     like: (nv, v) => {
-      const nodeValue = this.comparator.match(nv);
+      const nodeValue = comparator.match(nv);
       const value = v;
-      if (!this._cachedRegexp.has(value)) {
+      if (!cachedRegexp.has(value)) {
         const pattern = value.replace(/%/g, ".*").replace(/_/g, ".");
         const regexp2 = new RegExp(`^${pattern}$`, "i");
-        this._cachedRegexp.set(value, regexp2);
+        cachedRegexp.set(value, regexp2);
       }
-      const regexp = this._cachedRegexp.get(value);
+      const regexp = cachedRegexp.get(value);
       return regexp.test(nodeValue);
     }
   };
-  searchConfigs = {
+}
+function createSearchConfigs(comparator, ensureValues) {
+  const lowest = (v) => [...v].sort((a, b) => comparator.asc(a, b))[0];
+  const highest = (v) => [...v].sort((a, b) => comparator.asc(a, b))[v.length - 1];
+  const lowestPrimary = (v) => [...v].sort((a, b) => comparator.primaryAsc(a, b))[0];
+  const highestPrimary = (v) => [...v].sort((a, b) => comparator.primaryAsc(a, b))[v.length - 1];
+  return {
     gt: {
       asc: {
-        start: (tx, v) => tx.findUpperBoundLeaf(v[0]),
+        start: (r, ops, v) => findUpperBoundLeaf(ops, r, v[0], comparator),
         end: () => null,
         direction: 1,
         earlyTerminate: false
       },
       desc: {
-        start: (tx) => tx.rightestNode(),
-        end: (tx, v) => tx.findOuterBoundaryLeaf(v[0], -1),
+        start: (r, ops) => rightestNode(ops, r),
+        end: (r, ops, v) => findOuterBoundaryLeaf(ops, r, v[0], -1, comparator),
         direction: -1,
         earlyTerminate: true
       }
     },
     gte: {
       asc: {
-        start: (tx, v) => tx.findLowerBoundLeaf(v[0]),
+        start: (r, ops, v) => findLowerBoundLeaf(ops, r, v[0], comparator),
         end: () => null,
         direction: 1,
         earlyTerminate: false
       },
       desc: {
-        start: (tx) => tx.rightestNode(),
-        end: (tx, v) => tx.findOuterBoundaryLeaf(v[0], -1),
+        start: (r, ops) => rightestNode(ops, r),
+        end: (r, ops, v) => findOuterBoundaryLeaf(ops, r, v[0], -1, comparator),
         direction: -1,
         earlyTerminate: true
       }
     },
     lt: {
       asc: {
-        start: (tx) => tx.leftestNode(),
-        end: (tx, v) => tx.findOuterBoundaryLeaf(v[0], 1),
+        start: (r, ops) => leftestNode(ops, r),
+        end: (r, ops, v) => findOuterBoundaryLeaf(ops, r, v[0], 1, comparator),
         direction: 1,
         earlyTerminate: true
       },
       desc: {
-        start: (tx, v) => tx.findLowerBoundLeaf(v[0]),
+        start: (r, ops, v) => findLowerBoundLeaf(ops, r, v[0], comparator),
         end: () => null,
         direction: -1,
         earlyTerminate: false
@@ -1615,13 +1672,13 @@ var BPTreeTransaction = class _BPTreeTransaction {
     },
     lte: {
       asc: {
-        start: (tx) => tx.leftestNode(),
-        end: (tx, v) => tx.findOuterBoundaryLeaf(v[0], 1),
+        start: (r, ops) => leftestNode(ops, r),
+        end: (r, ops, v) => findOuterBoundaryLeaf(ops, r, v[0], 1, comparator),
         direction: 1,
         earlyTerminate: true
       },
       desc: {
-        start: (tx, v) => tx.findUpperBoundLeaf(v[0]),
+        start: (r, ops, v) => findUpperBoundLeaf(ops, r, v[0], comparator),
         end: () => null,
         direction: -1,
         earlyTerminate: false
@@ -1629,27 +1686,27 @@ var BPTreeTransaction = class _BPTreeTransaction {
     },
     equal: {
       asc: {
-        start: (tx, v) => tx.findLowerBoundLeaf(v[0]),
-        end: (tx, v) => tx.findOuterBoundaryLeaf(v[0], 1),
+        start: (r, ops, v) => findLowerBoundLeaf(ops, r, v[0], comparator),
+        end: (r, ops, v) => findOuterBoundaryLeaf(ops, r, v[0], 1, comparator),
         direction: 1,
         earlyTerminate: true
       },
       desc: {
-        start: (tx, v) => tx.findOuterBoundaryLeaf(v[0], 1),
-        end: (tx, v) => tx.findOuterBoundaryLeaf(v[0], -1),
+        start: (r, ops, v) => findOuterBoundaryLeaf(ops, r, v[0], 1, comparator),
+        end: (r, ops, v) => findOuterBoundaryLeaf(ops, r, v[0], -1, comparator),
         direction: -1,
         earlyTerminate: true
       }
     },
     notEqual: {
       asc: {
-        start: (tx) => tx.leftestNode(),
+        start: (r, ops) => leftestNode(ops, r),
         end: () => null,
         direction: 1,
         earlyTerminate: false
       },
       desc: {
-        start: (tx) => tx.rightestNode(),
+        start: (r, ops) => rightestNode(ops, r),
         end: () => null,
         direction: -1,
         earlyTerminate: false
@@ -1657,55 +1714,55 @@ var BPTreeTransaction = class _BPTreeTransaction {
     },
     or: {
       asc: {
-        start: (tx, v) => tx.findLowerBoundLeaf(tx.lowestValue(v)),
-        end: (tx, v) => tx.findOuterBoundaryLeaf(tx.highestValue(v), 1),
+        start: (r, ops, v) => findLowerBoundLeaf(ops, r, lowest(ensureValues(v)), comparator),
+        end: (r, ops, v) => findOuterBoundaryLeaf(ops, r, highest(ensureValues(v)), 1, comparator),
         direction: 1,
         earlyTerminate: false
       },
       desc: {
-        start: (tx, v) => tx.findOuterBoundaryLeaf(tx.highestValue(v), 1),
-        end: (tx, v) => tx.findOuterBoundaryLeaf(tx.lowestValue(v), -1),
+        start: (r, ops, v) => findOuterBoundaryLeaf(ops, r, highest(ensureValues(v)), 1, comparator),
+        end: (r, ops, v) => findOuterBoundaryLeaf(ops, r, lowest(ensureValues(v)), -1, comparator),
         direction: -1,
         earlyTerminate: false
       }
     },
     primaryGt: {
       asc: {
-        start: (tx, v) => tx.findUpperBoundLeaf(v[0]),
+        start: (r, ops, v) => findUpperBoundLeaf(ops, r, v[0], comparator),
         end: () => null,
         direction: 1,
         earlyTerminate: false
       },
       desc: {
-        start: (tx) => tx.rightestNode(),
-        end: (tx, v) => tx.findOuterBoundaryLeaf(v[0], -1),
+        start: (r, ops) => rightestNode(ops, r),
+        end: (r, ops, v) => findOuterBoundaryLeaf(ops, r, v[0], -1, comparator),
         direction: -1,
         earlyTerminate: true
       }
     },
     primaryGte: {
       asc: {
-        start: (tx, v) => tx.findLowerBoundLeaf(v[0]),
+        start: (r, ops, v) => findLowerBoundLeaf(ops, r, v[0], comparator),
         end: () => null,
         direction: 1,
         earlyTerminate: false
       },
       desc: {
-        start: (tx) => tx.rightestNode(),
-        end: (tx, v) => tx.findOuterBoundaryLeaf(v[0], -1),
+        start: (r, ops) => rightestNode(ops, r),
+        end: (r, ops, v) => findOuterBoundaryLeaf(ops, r, v[0], -1, comparator),
         direction: -1,
         earlyTerminate: true
       }
     },
     primaryLt: {
       asc: {
-        start: (tx) => tx.leftestNode(),
-        end: (tx, v) => tx.findOuterBoundaryLeaf(v[0], 1),
+        start: (r, ops) => leftestNode(ops, r),
+        end: (r, ops, v) => findOuterBoundaryLeaf(ops, r, v[0], 1, comparator),
         direction: 1,
         earlyTerminate: true
       },
       desc: {
-        start: (tx, v) => tx.findLowerBoundLeaf(v[0]),
+        start: (r, ops, v) => findLowerBoundLeaf(ops, r, v[0], comparator),
         end: () => null,
         direction: -1,
         earlyTerminate: false
@@ -1713,13 +1770,13 @@ var BPTreeTransaction = class _BPTreeTransaction {
     },
     primaryLte: {
       asc: {
-        start: (tx) => tx.leftestNode(),
-        end: (tx, v) => tx.findOuterBoundaryLeaf(v[0], 1),
+        start: (r, ops) => leftestNode(ops, r),
+        end: (r, ops, v) => findOuterBoundaryLeaf(ops, r, v[0], 1, comparator),
         direction: 1,
         earlyTerminate: true
       },
       desc: {
-        start: (tx, v) => tx.findUpperBoundLeaf(v[0]),
+        start: (r, ops, v) => findUpperBoundLeaf(ops, r, v[0], comparator),
         end: () => null,
         direction: -1,
         earlyTerminate: false
@@ -1727,27 +1784,27 @@ var BPTreeTransaction = class _BPTreeTransaction {
     },
     primaryEqual: {
       asc: {
-        start: (tx, v) => tx.findLowerBoundLeaf(v[0]),
-        end: (tx, v) => tx.findOuterBoundaryLeaf(v[0], 1),
+        start: (r, ops, v) => findLowerBoundLeaf(ops, r, v[0], comparator),
+        end: (r, ops, v) => findOuterBoundaryLeaf(ops, r, v[0], 1, comparator),
         direction: 1,
         earlyTerminate: true
       },
       desc: {
-        start: (tx, v) => tx.findUpperBoundLeaf(v[0]),
-        end: (tx, v) => tx.findOuterBoundaryLeaf(v[0], -1),
+        start: (r, ops, v) => findUpperBoundLeaf(ops, r, v[0], comparator),
+        end: (r, ops, v) => findOuterBoundaryLeaf(ops, r, v[0], -1, comparator),
         direction: -1,
         earlyTerminate: true
       }
     },
     primaryNotEqual: {
       asc: {
-        start: (tx) => tx.leftestNode(),
+        start: (r, ops) => leftestNode(ops, r),
         end: () => null,
         direction: 1,
         earlyTerminate: false
       },
       desc: {
-        start: (tx) => tx.rightestNode(),
+        start: (r, ops) => rightestNode(ops, r),
         end: () => null,
         direction: -1,
         earlyTerminate: false
@@ -1755,176 +1812,1186 @@ var BPTreeTransaction = class _BPTreeTransaction {
     },
     primaryOr: {
       asc: {
-        start: (tx, v) => tx.findLowerBoundLeaf(tx.lowestPrimaryValue(v)),
-        end: (tx, v) => tx.findOuterBoundaryLeaf(tx.highestPrimaryValue(v), 1),
+        start: (r, ops, v) => findLowerBoundLeaf(ops, r, lowestPrimary(ensureValues(v)), comparator),
+        end: (r, ops, v) => findOuterBoundaryLeaf(ops, r, highestPrimary(ensureValues(v)), 1, comparator),
         direction: 1,
         earlyTerminate: false
       },
       desc: {
-        start: (tx, v) => tx.findUpperBoundLeaf(tx.highestPrimaryValue(v)),
-        end: (tx, v) => tx.findOuterBoundaryLeaf(tx.lowestPrimaryValue(v), -1),
+        start: (r, ops, v) => findUpperBoundLeaf(ops, r, highestPrimary(ensureValues(v)), comparator),
+        end: (r, ops, v) => findOuterBoundaryLeaf(ops, r, lowestPrimary(ensureValues(v)), -1, comparator),
         direction: -1,
         earlyTerminate: false
       }
     },
     like: {
       asc: {
-        start: (tx) => tx.leftestNode(),
+        start: (r, ops) => leftestNode(ops, r),
         end: () => null,
         direction: 1,
         earlyTerminate: false
       },
       desc: {
-        start: (tx) => tx.rightestNode(),
+        start: (r, ops) => rightestNode(ops, r),
         end: () => null,
         direction: -1,
         earlyTerminate: false
       }
     }
   };
-  /**
-   * Priority map for condition types.
-   * Higher value = higher selectivity (fewer expected results).
-   * Used by `chooseDriver` to select the most selective index.
-   */
-  static conditionPriority = {
-    equal: 100,
-    primaryEqual: 100,
-    or: 80,
-    primaryOr: 80,
-    gt: 50,
-    gte: 50,
-    lt: 50,
-    lte: 50,
-    primaryGt: 50,
-    primaryGte: 50,
-    primaryLt: 50,
-    primaryLte: 50,
-    like: 30,
-    notEqual: 10,
-    primaryNotEqual: 10
-  };
-  /**
-   * Selects the best driver tree from multiple tree/condition pairs.
-   * Uses rule-based optimization to choose the tree with highest estimated selectivity.
-   * 
-   * @param candidates Array of { tree, condition } pairs to evaluate
-   * @returns The candidate with highest priority condition, or null if empty
-   * 
-   * @example
-   * ```typescript
-   * const driver = BPTreeSync.chooseDriver([
-   *   { tree: idxId, condition: { equal: 100 } },
-   *   { tree: idxAge, condition: { gt: 20 } }
-   * ])
-   * // Returns { tree: idxId, condition: { equal: 100 } } because 'equal' has higher priority
-   * ```
-   */
-  static ChooseDriver(candidates) {
-    if (candidates.length === 0) return null;
-    if (candidates.length === 1) return candidates[0];
-    let best = candidates[0];
-    let bestScore = 0;
-    for (const candidate of candidates) {
-      let score = 0;
-      for (const key in candidate.condition) {
-        const condKey = key;
-        const priority = _BPTreeTransaction.conditionPriority[condKey] ?? 0;
-        if (priority > score) {
-          score = priority;
-        }
-      }
-      if (score > bestScore) {
-        bestScore = score;
-        best = candidate;
-      }
+}
+var _lowerBoundKeys = [
+  "primaryEqual",
+  "equal",
+  "primaryGt",
+  "gt",
+  "primaryGte",
+  "gte",
+  "primaryOr",
+  "or"
+];
+var _upperBoundKeys = [
+  "primaryEqual",
+  "equal",
+  "primaryLt",
+  "lt",
+  "primaryLte",
+  "lte",
+  "primaryOr",
+  "or"
+];
+var _multiValueKeys = [
+  "or",
+  "primaryOr"
+];
+function resolveStartEndConfigs(condition, order, comparator, ensureValues) {
+  const direction = order === "asc" ? 1 : -1;
+  const startCandidates = order === "asc" ? _lowerBoundKeys : _upperBoundKeys;
+  const endCandidates = order === "asc" ? _upperBoundKeys : _lowerBoundKeys;
+  let startKey = null;
+  let endKey = null;
+  let startValues = [];
+  let endValues = [];
+  for (let i = 0, len = startCandidates.length; i < len; i++) {
+    const key = startCandidates[i];
+    if (key in condition) {
+      startKey = key;
+      startValues = _multiValueKeys.includes(key) ? ensureValues(condition[key]) : [condition[key]];
+      break;
     }
-    return best;
   }
-  /**
-   * Checks for conflicts between multiple transactions.
-   * 
-   * @param transactions Array of BPTreeTransaction instances to check
-   * @returns An array of keys that are in conflict. Empty array if no conflicts.
-   */
-  static CheckConflicts(transactions) {
-    return MVCCTransaction.CheckConflicts(transactions.map((tx) => tx.mvcc));
+  for (let i = 0, len = endCandidates.length; i < len; i++) {
+    const key = endCandidates[i];
+    if (key in condition) {
+      endKey = key;
+      endValues = _multiValueKeys.includes(key) ? ensureValues(condition[key]) : [condition[key]];
+      break;
+    }
   }
-  /**
-   * Returns the ID of the root node.
-   * @returns The root node ID.
-   */
-  getRootId() {
-    return this.rootId;
+  return { startKey, endKey, startValues, endValues, direction };
+}
+function verify(nodeValue, condition, verifierMap) {
+  for (const key in condition) {
+    const verifyFn = verifierMap[key];
+    const condValue = condition[key];
+    if (!verifyFn(nodeValue, condValue)) {
+      return false;
+    }
   }
-  /**
-   * Returns the order of the B+Tree.
-   * @returns The order of the tree.
-   */
-  getOrder() {
-    return this.order;
+  return true;
+}
+function locateLeaf(ops, rootId, value, comparator) {
+  let node = ops.getNode(rootId);
+  while (!node.leaf) {
+    const { index } = binarySearchValues(node.values, value, comparator, false, true);
+    node = ops.getNode(node.keys[index]);
+  }
+  return node;
+}
+function findLowerBoundLeaf(ops, rootId, value, comparator) {
+  let node = ops.getNode(rootId);
+  while (!node.leaf) {
+    const { index } = binarySearchValues(node.values, value, comparator, true, false);
+    node = ops.getNode(node.keys[index]);
+  }
+  return node;
+}
+function findUpperBoundLeaf(ops, rootId, value, comparator) {
+  let node = ops.getNode(rootId);
+  while (!node.leaf) {
+    const { index } = binarySearchValues(node.values, value, comparator, true, true);
+    node = ops.getNode(node.keys[index]);
+  }
+  return node;
+}
+function findOuterBoundaryLeaf(ops, rootId, value, direction, comparator) {
+  const insertableNode = direction === -1 ? findLowerBoundLeaf(ops, rootId, value, comparator) : findUpperBoundLeaf(ops, rootId, value, comparator);
+  let key;
+  switch (direction) {
+    case -1:
+      key = "prev";
+      break;
+    case 1:
+      key = "next";
+      break;
+    default:
+      throw new Error(`Direction must be -1 or 1. but got a ${direction}`);
   }
-  /**
-   * Verified if the value satisfies the condition.
-   * 
-   * @param nodeValue The value to verify.
-   * @param condition The condition to verify against.
-   * @returns Returns true if the value satisfies the condition.
-   */
-  verify(nodeValue, condition) {
-    for (const key in condition) {
-      const verify = this.verifierMap[key];
-      const condValue = condition[key];
-      if (!verify(nodeValue, condValue)) {
-        return false;
-      }
-    }
-    return true;
+  const guessNode = insertableNode[key];
+  if (!guessNode) {
+    return null;
   }
-  /**
-   * Inserts a key-value pair into an already-cloned leaf node in-place.
-   * Unlike _insertAtLeaf, this does NOT clone or update the node via MVCC.
-   * Used by batchInsert to batch multiple insertions with a single clone/update.
-   * @returns true if the leaf was modified, false if the key already exists.
-   */
-  _insertValueIntoLeaf(leaf, key, value) {
-    if (leaf.values.length) {
-      const { index, found } = this._binarySearchValues(leaf.values, value);
-      if (found) {
-        if (leaf.keys[index].includes(key)) {
-          return false;
+  return ops.getNode(guessNode);
+}
+function leftestNode(ops, rootId) {
+  let node = ops.getNode(rootId);
+  while (!node.leaf) {
+    const keys = node.keys;
+    node = ops.getNode(keys[0]);
+  }
+  return node;
+}
+function rightestNode(ops, rootId) {
+  let node = ops.getNode(rootId);
+  while (!node.leaf) {
+    const keys = node.keys;
+    node = ops.getNode(keys[keys.length - 1]);
+  }
+  return node;
+}
+function* getPairsGenerator(ops, startNode, endNode, direction) {
+  let node = startNode;
+  while (true) {
+    if (endNode && node.id === endNode.id) {
+      break;
+    }
+    const len = node.values.length;
+    if (direction === 1) {
+      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++) {
+          yield [keys[j], nValue];
         }
-        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;
+      let i = len;
+      while (i--) {
+        const nValue = node.values[i];
+        const keys = node.keys[i];
+        let j = keys.length;
+        while (j--) {
+          yield [keys[j], nValue];
+        }
+      }
     }
+    if (direction === 1) {
+      if (!node.next) break;
+      node = ops.getNode(node.next);
+    } else {
+      if (!node.prev) break;
+      node = ops.getNode(node.prev);
+    }
+  }
+}
+function insertAtLeaf(ops, node, key, value, comparator) {
+  let leaf = node;
+  if (leaf.values.length) {
+    for (let i = 0, len = leaf.values.length; i < len; i++) {
+      const nValue = leaf.values[i];
+      if (comparator.isSame(value, nValue)) {
+        const keys = leaf.keys[i];
+        if (keys.includes(key)) {
+          break;
+        }
+        leaf = cloneNode(leaf);
+        leaf.keys[i].push(key);
+        ops.updateNode(leaf);
+        return leaf;
+      } else if (comparator.isLower(value, nValue)) {
+        leaf = cloneNode(leaf);
+        leaf.values.splice(i, 0, value);
+        leaf.keys.splice(i, 0, [key]);
+        ops.updateNode(leaf);
+        return leaf;
+      } else if (i + 1 === leaf.values.length) {
+        leaf = cloneNode(leaf);
+        leaf.values.push(value);
+        leaf.keys.push([key]);
+        ops.updateNode(leaf);
+        return leaf;
+      }
+    }
+  } else {
+    leaf = cloneNode(leaf);
+    leaf.values = [value];
+    leaf.keys = [[key]];
+    ops.updateNode(leaf);
+    return leaf;
   }
-  _cloneNode(node) {
-    return JSON.parse(JSON.stringify(node));
+  return leaf;
+}
+function insertInParent(ops, ctx, node, value, newSiblingNode) {
+  if (ctx.rootId === node.id) {
+    node = cloneNode(node);
+    newSiblingNode = cloneNode(newSiblingNode);
+    const root = ops.createNode(false, [node.id, newSiblingNode.id], [value]);
+    ctx.rootId = root.id;
+    node.parent = root.id;
+    newSiblingNode.parent = root.id;
+    if (newSiblingNode.leaf) {
+      ;
+      node.next = newSiblingNode.id;
+      newSiblingNode.prev = node.id;
+    }
+    ops.writeHead({
+      root: root.id,
+      order: ctx.order,
+      data: ctx.headData()
+    });
+    ops.updateNode(node);
+    ops.updateNode(newSiblingNode);
+    return;
+  }
+  const parentNode = cloneNode(ops.getNode(node.parent));
+  const nodeIndex = parentNode.keys.indexOf(node.id);
+  if (nodeIndex === -1) {
+    throw new Error(`Node ${node.id} not found in parent ${parentNode.id}`);
+  }
+  parentNode.values.splice(nodeIndex, 0, value);
+  parentNode.keys.splice(nodeIndex + 1, 0, newSiblingNode.id);
+  newSiblingNode = cloneNode(newSiblingNode);
+  newSiblingNode.parent = parentNode.id;
+  if (newSiblingNode.leaf) {
+    const leftSibling = cloneNode(node);
+    const oldNextId = leftSibling.next;
+    newSiblingNode.prev = leftSibling.id;
+    newSiblingNode.next = oldNextId;
+    leftSibling.next = newSiblingNode.id;
+    ops.updateNode(leftSibling);
+    if (oldNextId) {
+      const oldNext = cloneNode(ops.getNode(oldNextId));
+      oldNext.prev = newSiblingNode.id;
+      ops.updateNode(oldNext);
+    }
+  }
+  ops.updateNode(parentNode);
+  ops.updateNode(newSiblingNode);
+  if (parentNode.keys.length > ctx.order) {
+    const newSiblingNodeRecursive = ops.createNode(false, [], []);
+    newSiblingNodeRecursive.parent = parentNode.parent;
+    const mid = Math.ceil(ctx.order / 2) - 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);
+    for (let i = 0, len = newSiblingNodeRecursive.keys.length; i < len; i++) {
+      const k = newSiblingNodeRecursive.keys[i];
+      const n = cloneNode(ops.getNode(k));
+      n.parent = newSiblingNodeRecursive.id;
+      ops.updateNode(n);
+    }
+    ops.updateNode(parentNode);
+    insertInParent(ops, ctx, parentNode, midValue, newSiblingNodeRecursive);
+  }
+}
+function insertOp(ops, ctx, key, value, comparator) {
+  let before = locateLeaf(ops, ctx.rootId, value, comparator);
+  before = insertAtLeaf(ops, before, key, value, comparator);
+  if (before.values.length === ctx.order) {
+    let after = ops.createNode(
+      true,
+      [],
+      [],
+      before.parent,
+      null,
+      null
+    );
+    const mid = Math.ceil(ctx.order / 2) - 1;
+    after = cloneNode(after);
+    after.values = before.values.slice(mid + 1);
+    after.keys = before.keys.slice(mid + 1);
+    before.values = before.values.slice(0, mid + 1);
+    before.keys = before.keys.slice(0, mid + 1);
+    ops.updateNode(before);
+    ops.updateNode(after);
+    insertInParent(ops, ctx, before, after.values[0], after);
+  }
+}
+function deleteEntry(ops, ctx, node, key, comparator) {
+  if (!node.leaf) {
+    let keyIndex = -1;
+    for (let i = 0, len = node.keys.length; i < len; i++) {
+      if (node.keys[i] === key) {
+        keyIndex = i;
+        break;
+      }
+    }
+    if (keyIndex !== -1) {
+      node = cloneNode(node);
+      node.keys.splice(keyIndex, 1);
+      const valueIndex = keyIndex > 0 ? keyIndex - 1 : 0;
+      node.values.splice(valueIndex, 1);
+      ops.updateNode(node);
+    }
   }
-  /**
-   * Resolves the best start/end configuration by independently examining
-   * all conditions. Selects the tightest lower bound for start and the
-   * tightest upper bound for end (in asc; reversed for desc).
-   *
-   * @param condition The condition to analyze.
-   * @param order The sort order ('asc' or 'desc').
-   * @returns The resolved start/end keys, values, and traversal direction.
-   */
-  resolveStartEndConfigs(condition, order) {
-    const direction = order === "asc" ? 1 : -1;
-    const startCandidates = order === "asc" ? _BPTreeTransaction._lowerBoundKeys : _BPTreeTransaction._upperBoundKeys;
-    const endCandidates = order === "asc" ? _BPTreeTransaction._upperBoundKeys : _BPTreeTransaction._lowerBoundKeys;
-    let startKey = null;
-    let endKey = null;
-    let startValues = [];
+  if (ctx.rootId === node.id && node.keys.length === 1 && !node.leaf) {
+    const keys = node.keys;
+    ops.deleteNode(node);
+    const newRoot = cloneNode(ops.getNode(keys[0]));
+    newRoot.parent = null;
+    ops.updateNode(newRoot);
+    ops.writeHead({
+      root: newRoot.id,
+      order: ctx.order,
+      data: ctx.headData()
+    });
+    ctx.rootId = newRoot.id;
+    return node;
+  } else if (ctx.rootId === node.id) {
+    ops.writeHead({
+      root: node.id,
+      order: ctx.order,
+      data: ctx.headData()
+    });
+    return node;
+  } else if (node.keys.length < Math.ceil(ctx.order / 2) && !node.leaf || node.values.length < Math.ceil((ctx.order - 1) / 2) && node.leaf) {
+    if (node.parent === null) {
+      return node;
+    }
+    let isPredecessor = false;
+    let parentNode = ops.getNode(node.parent);
+    let prevNode = null;
+    let nextNode = null;
+    let prevValue = null;
+    let postValue = null;
+    for (let i = 0, len = parentNode.keys.length; i < len; i++) {
+      const nKey = parentNode.keys[i];
+      if (nKey === node.id) {
+        if (i > 0) {
+          prevNode = ops.getNode(parentNode.keys[i - 1]);
+          prevValue = parentNode.values[i - 1];
+        }
+        if (i < parentNode.keys.length - 1) {
+          nextNode = ops.getNode(parentNode.keys[i + 1]);
+          postValue = parentNode.values[i];
+        }
+      }
+    }
+    let siblingNode;
+    let guess;
+    if (prevNode === null) {
+      siblingNode = nextNode;
+      guess = postValue;
+    } else if (nextNode === null) {
+      isPredecessor = true;
+      siblingNode = prevNode;
+      guess = prevValue;
+    } else {
+      if (node.values.length + nextNode.values.length < ctx.order) {
+        siblingNode = nextNode;
+        guess = postValue;
+      } else {
+        isPredecessor = true;
+        siblingNode = prevNode;
+        guess = prevValue;
+      }
+    }
+    if (!siblingNode) {
+      return node;
+    }
+    node = cloneNode(node);
+    siblingNode = cloneNode(siblingNode);
+    if (node.values.length + siblingNode.values.length < ctx.order) {
+      if (!isPredecessor) {
+        const pTemp = siblingNode;
+        siblingNode = node;
+        node = pTemp;
+      }
+      siblingNode.keys.push(...node.keys);
+      if (!node.leaf) {
+        siblingNode.values.push(guess);
+      } else {
+        siblingNode.next = node.next;
+        if (siblingNode.next) {
+          const n = cloneNode(ops.getNode(siblingNode.next));
+          n.prev = siblingNode.id;
+          ops.updateNode(n);
+        }
+      }
+      siblingNode.values.push(...node.values);
+      if (!siblingNode.leaf) {
+        const keys = siblingNode.keys;
+        for (let i = 0, len = keys.length; i < len; i++) {
+          const k = keys[i];
+          const n = cloneNode(ops.getNode(k));
+          n.parent = siblingNode.id;
+          ops.updateNode(n);
+        }
+      }
+      ops.deleteNode(node);
+      ops.updateNode(siblingNode);
+      deleteEntry(ops, ctx, ops.getNode(node.parent), node.id, comparator);
+    } else {
+      if (isPredecessor) {
+        let pointerPm;
+        let pointerKm;
+        if (!node.leaf) {
+          pointerPm = siblingNode.keys.splice(-1)[0];
+          pointerKm = siblingNode.values.splice(-1)[0];
+          node.keys = [pointerPm, ...node.keys];
+          node.values = [guess, ...node.values];
+          parentNode = cloneNode(ops.getNode(node.parent));
+          const nodeIndex = parentNode.keys.indexOf(node.id);
+          if (nodeIndex > 0) {
+            parentNode.values[nodeIndex - 1] = pointerKm;
+            ops.updateNode(parentNode);
+          }
+        } else {
+          pointerPm = siblingNode.keys.splice(-1)[0];
+          pointerKm = siblingNode.values.splice(-1)[0];
+          node.keys = [pointerPm, ...node.keys];
+          node.values = [pointerKm, ...node.values];
+          parentNode = cloneNode(ops.getNode(node.parent));
+          const nodeIndex = parentNode.keys.indexOf(node.id);
+          if (nodeIndex > 0) {
+            parentNode.values[nodeIndex - 1] = pointerKm;
+            ops.updateNode(parentNode);
+          }
+        }
+        ops.updateNode(node);
+        ops.updateNode(siblingNode);
+      } else {
+        let pointerP0;
+        let pointerK0;
+        if (!node.leaf) {
+          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 = cloneNode(ops.getNode(node.parent));
+          const pointerIndex = parentNode.keys.indexOf(siblingNode.id);
+          if (pointerIndex > 0) {
+            parentNode.values[pointerIndex - 1] = pointerK0;
+            ops.updateNode(parentNode);
+          }
+        } else {
+          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 = cloneNode(ops.getNode(node.parent));
+          const pointerIndex = parentNode.keys.indexOf(siblingNode.id);
+          if (pointerIndex > 0) {
+            parentNode.values[pointerIndex - 1] = siblingNode.values[0];
+            ops.updateNode(parentNode);
+          }
+        }
+        ops.updateNode(node);
+        ops.updateNode(siblingNode);
+      }
+      if (!siblingNode.leaf) {
+        for (let i = 0, len = siblingNode.keys.length; i < len; i++) {
+          const k = siblingNode.keys[i];
+          const n = cloneNode(ops.getNode(k));
+          n.parent = siblingNode.id;
+          ops.updateNode(n);
+        }
+      }
+      if (!node.leaf) {
+        for (let i = 0, len = node.keys.length; i < len; i++) {
+          const k = node.keys[i];
+          const n = cloneNode(ops.getNode(k));
+          n.parent = node.id;
+          ops.updateNode(n);
+        }
+      }
+      if (!parentNode.leaf) {
+        for (let i = 0, len = parentNode.keys.length; i < len; i++) {
+          const k = parentNode.keys[i];
+          const n = cloneNode(ops.getNode(k));
+          n.parent = parentNode.id;
+          ops.updateNode(n);
+        }
+      }
+    }
+  } else {
+    ops.updateNode(cloneNode(node));
+  }
+  return node;
+}
+function deleteOp(ops, ctx, key, comparator, value) {
+  if (value === void 0) {
+    value = getOp(ops, ctx.rootId, key);
+  }
+  if (value === void 0) {
+    return;
+  }
+  let node = findLowerBoundLeaf(ops, ctx.rootId, value, comparator);
+  let found = false;
+  while (true) {
+    let i = node.values.length;
+    while (i--) {
+      const nValue = node.values[i];
+      if (comparator.isSame(value, nValue)) {
+        const keys = node.keys[i];
+        const keyIndex = keys.indexOf(key);
+        if (keyIndex !== -1) {
+          node = 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);
+          }
+          ops.updateNode(node);
+          node = deleteEntry(ops, ctx, node, key, comparator);
+          found = true;
+          break;
+        }
+      }
+    }
+    if (found) break;
+    if (node.next) {
+      node = ops.getNode(node.next);
+      continue;
+    }
+    break;
+  }
+}
+function batchInsertOp(ops, ctx, entries, comparator) {
+  if (entries.length === 0) return;
+  const sorted = [...entries].sort((a, b) => comparator.asc(a[1], b[1]));
+  let currentLeaf = null;
+  let modified = false;
+  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 && (comparator.isLower(value, cachedLeafMaxValue) || comparator.isSame(value, cachedLeafMaxValue))) {
+      targetLeaf = currentLeaf;
+    } else {
+      targetLeaf = locateLeaf(ops, ctx.rootId, value, comparator);
+    }
+    if (currentLeaf !== null && currentLeaf.id === targetLeaf.id) {
+    } else {
+      if (currentLeaf !== null && modified) {
+        ops.updateNode(currentLeaf);
+      }
+      currentLeaf = cloneNode(targetLeaf);
+      modified = false;
+    }
+    cachedLeafId = currentLeaf.id;
+    const changed = insertValueIntoLeaf(currentLeaf, key, value, comparator);
+    modified = modified || changed;
+    cachedLeafMaxValue = currentLeaf.values[currentLeaf.values.length - 1];
+    if (currentLeaf.values.length === ctx.order) {
+      ops.updateNode(currentLeaf);
+      let after = ops.createNode(
+        true,
+        [],
+        [],
+        currentLeaf.parent,
+        null,
+        null
+      );
+      const mid = Math.ceil(ctx.order / 2) - 1;
+      after = cloneNode(after);
+      after.values = currentLeaf.values.slice(mid + 1);
+      after.keys = currentLeaf.keys.slice(mid + 1);
+      currentLeaf.values = currentLeaf.values.slice(0, mid + 1);
+      currentLeaf.keys = currentLeaf.keys.slice(0, mid + 1);
+      ops.updateNode(currentLeaf);
+      ops.updateNode(after);
+      insertInParent(ops, ctx, currentLeaf, after.values[0], after);
+      currentLeaf = null;
+      cachedLeafId = null;
+      cachedLeafMaxValue = null;
+      modified = false;
+    }
+  }
+  if (currentLeaf !== null && modified) {
+    ops.updateNode(currentLeaf);
+  }
+}
+function bulkLoadOp(ops, ctx, entries, comparator) {
+  if (entries.length === 0) return;
+  const root = ops.getNode(ctx.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) => 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 && comparator.isSame(last.value, value)) {
+      if (!last.keys.includes(key)) {
+        last.keys.push(key);
+      }
+    } else {
+      grouped.push({ keys: [key], value });
+    }
+  }
+  ops.deleteNode(root);
+  const maxLeafSize = ctx.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 = ops.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;
+    }
+    ops.updateNode(leaves[i]);
+  }
+  let currentLevel = leaves;
+  while (currentLevel.length > 1) {
+    const nextLevel = [];
+    for (let i = 0, len = currentLevel.length; i < len; i += ctx.order) {
+      const children = currentLevel.slice(i, i + ctx.order);
+      const childIds = children.map((c) => c.id);
+      const separators = [];
+      for (let j = 1, cLen = children.length; j < cLen; j++) {
+        separators.push(children[j].values[0]);
+      }
+      const internalNode = ops.createNode(
+        false,
+        childIds,
+        separators,
+        null,
+        null,
+        null
+      );
+      for (let j = 0, cLen = children.length; j < cLen; j++) {
+        const child = children[j];
+        child.parent = internalNode.id;
+        ops.updateNode(child);
+      }
+      nextLevel.push(internalNode);
+    }
+    currentLevel = nextLevel;
+  }
+  const newRoot = currentLevel[0];
+  ops.writeHead({
+    root: newRoot.id,
+    order: ctx.order,
+    data: ctx.headData()
+  });
+  ctx.rootId = newRoot.id;
+}
+function existsOp(ops, rootId, key, value, comparator) {
+  const node = locateLeaf(ops, rootId, value, comparator);
+  const { index, found } = binarySearchValues(node.values, value, comparator);
+  if (found) {
+    const keys = node.keys[index];
+    if (keys.includes(key)) {
+      return true;
+    }
+  }
+  return false;
+}
+function getOp(ops, rootId, key) {
+  let node = leftestNode(ops, rootId);
+  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++) {
+        if (keys[j] === key) {
+          return node.values[i];
+        }
+      }
+    }
+    if (!node.next) break;
+    node = ops.getNode(node.next);
+  }
+  return void 0;
+}
+function* whereStreamOp(ops, rootId, condition, comparator, verifierMap, searchConfigs, ensureValues, options) {
+  const { filterValues, limit, order = "asc" } = options ?? {};
+  const conditionKeys = Object.keys(condition);
+  if (conditionKeys.length === 0) return;
+  const resolved = resolveStartEndConfigs(condition, order, comparator, ensureValues);
+  const direction = resolved.direction;
+  let startNode;
+  if (resolved.startKey) {
+    const startConfig = searchConfigs[resolved.startKey][order];
+    startNode = startConfig.start(rootId, ops, resolved.startValues);
+  } else {
+    startNode = order === "asc" ? leftestNode(ops, rootId) : rightestNode(ops, rootId);
+  }
+  let endNode = null;
+  if (resolved.endKey) {
+    const endConfig = searchConfigs[resolved.endKey][order];
+    endNode = endConfig.end(rootId, ops, resolved.endValues);
+  }
+  if (!startNode) return;
+  const generator = getPairsGenerator(ops, startNode, endNode, direction);
+  let count = 0;
+  const intersection = filterValues && filterValues.size > 0 ? filterValues : null;
+  for (const pair of generator) {
+    const [k, v] = pair;
+    if (intersection && !intersection.has(k)) {
+      continue;
+    }
+    if (verify(v, condition, verifierMap)) {
+      yield pair;
+      count++;
+      if (limit !== void 0 && count >= limit) {
+        break;
+      }
+    }
+  }
+}
+function* keysStreamOp(ops, rootId, condition, comparator, verifierMap, searchConfigs, ensureValues, options) {
+  const { filterValues, limit } = options ?? {};
+  const stream = whereStreamOp(ops, rootId, condition, comparator, verifierMap, searchConfigs, ensureValues, options);
+  const intersection = filterValues && filterValues.size > 0 ? filterValues : null;
+  let count = 0;
+  for (const [key] of stream) {
+    if (intersection && !intersection.has(key)) {
+      continue;
+    }
+    yield key;
+    count++;
+    if (limit !== void 0 && count >= limit) {
+      break;
+    }
+  }
+}
+function initOp(ops, ctx, strategyOrder, strategyHead, setStrategyHead) {
+  const head = ops.readHead();
+  if (head === null) {
+    ctx.order = strategyOrder;
+    const root = ops.createNode(true, [], []);
+    ops.writeHead({
+      root: root.id,
+      order: ctx.order,
+      data: strategyHead.data
+    });
+    ctx.rootId = root.id;
+  } else {
+    const { root, order } = head;
+    setStrategyHead(head);
+    ctx.order = order;
+    ctx.rootId = root;
+  }
+  if (ctx.order < 3) {
+    throw new Error(`The 'order' parameter must be greater than 2. but got a '${ctx.order}'.`);
+  }
+}
+
+// src/base/BPTreeTransaction.ts
+var BPTreeTransaction = class _BPTreeTransaction {
+  _cachedRegexp = /* @__PURE__ */ new Map();
+  rootTx;
+  mvccRoot;
+  mvcc;
+  strategy;
+  comparator;
+  option;
+  order;
+  rootId;
+  isInitialized = false;
+  isDestroyed = false;
+  verifierMap = {
+    gt: (nv, v) => this.comparator.isHigher(nv, v),
+    gte: (nv, v) => this.comparator.isHigher(nv, v) || this.comparator.isSame(nv, v),
+    lt: (nv, v) => this.comparator.isLower(nv, v),
+    lte: (nv, v) => this.comparator.isLower(nv, v) || this.comparator.isSame(nv, v),
+    equal: (nv, v) => this.comparator.isSame(nv, v),
+    notEqual: (nv, v) => this.comparator.isSame(nv, v) === false,
+    or: (nv, v) => this.ensureValues(v).some((v2) => this.comparator.isSame(nv, v2)),
+    primaryGt: (nv, v) => this.comparator.isPrimaryHigher(nv, v),
+    primaryGte: (nv, v) => this.comparator.isPrimaryHigher(nv, v) || this.comparator.isPrimarySame(nv, v),
+    primaryLt: (nv, v) => this.comparator.isPrimaryLower(nv, v),
+    primaryLte: (nv, v) => this.comparator.isPrimaryLower(nv, v) || this.comparator.isPrimarySame(nv, v),
+    primaryEqual: (nv, v) => this.comparator.isPrimarySame(nv, v),
+    primaryNotEqual: (nv, v) => this.comparator.isPrimarySame(nv, v) === false,
+    primaryOr: (nv, v) => this.ensureValues(v).some((v2) => this.comparator.isPrimarySame(nv, v2)),
+    like: (nv, v) => {
+      const nodeValue = this.comparator.match(nv);
+      const value = v;
+      if (!this._cachedRegexp.has(value)) {
+        const pattern = value.replace(/%/g, ".*").replace(/_/g, ".");
+        const regexp2 = new RegExp(`^${pattern}$`, "i");
+        this._cachedRegexp.set(value, regexp2);
+      }
+      const regexp = this._cachedRegexp.get(value);
+      return regexp.test(nodeValue);
+    }
+  };
+  searchConfigs = {
+    gt: {
+      asc: {
+        start: (tx, v) => tx.findUpperBoundLeaf(v[0]),
+        end: () => null,
+        direction: 1,
+        earlyTerminate: false
+      },
+      desc: {
+        start: (tx) => tx.rightestNode(),
+        end: (tx, v) => tx.findOuterBoundaryLeaf(v[0], -1),
+        direction: -1,
+        earlyTerminate: true
+      }
+    },
+    gte: {
+      asc: {
+        start: (tx, v) => tx.findLowerBoundLeaf(v[0]),
+        end: () => null,
+        direction: 1,
+        earlyTerminate: false
+      },
+      desc: {
+        start: (tx) => tx.rightestNode(),
+        end: (tx, v) => tx.findOuterBoundaryLeaf(v[0], -1),
+        direction: -1,
+        earlyTerminate: true
+      }
+    },
+    lt: {
+      asc: {
+        start: (tx) => tx.leftestNode(),
+        end: (tx, v) => tx.findOuterBoundaryLeaf(v[0], 1),
+        direction: 1,
+        earlyTerminate: true
+      },
+      desc: {
+        start: (tx, v) => tx.findLowerBoundLeaf(v[0]),
+        end: () => null,
+        direction: -1,
+        earlyTerminate: false
+      }
+    },
+    lte: {
+      asc: {
+        start: (tx) => tx.leftestNode(),
+        end: (tx, v) => tx.findOuterBoundaryLeaf(v[0], 1),
+        direction: 1,
+        earlyTerminate: true
+      },
+      desc: {
+        start: (tx, v) => tx.findUpperBoundLeaf(v[0]),
+        end: () => null,
+        direction: -1,
+        earlyTerminate: false
+      }
+    },
+    equal: {
+      asc: {
+        start: (tx, v) => tx.findLowerBoundLeaf(v[0]),
+        end: (tx, v) => tx.findOuterBoundaryLeaf(v[0], 1),
+        direction: 1,
+        earlyTerminate: true
+      },
+      desc: {
+        start: (tx, v) => tx.findOuterBoundaryLeaf(v[0], 1),
+        end: (tx, v) => tx.findOuterBoundaryLeaf(v[0], -1),
+        direction: -1,
+        earlyTerminate: true
+      }
+    },
+    notEqual: {
+      asc: {
+        start: (tx) => tx.leftestNode(),
+        end: () => null,
+        direction: 1,
+        earlyTerminate: false
+      },
+      desc: {
+        start: (tx) => tx.rightestNode(),
+        end: () => null,
+        direction: -1,
+        earlyTerminate: false
+      }
+    },
+    or: {
+      asc: {
+        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.findOuterBoundaryLeaf(tx.highestValue(v), 1),
+        end: (tx, v) => tx.findOuterBoundaryLeaf(tx.lowestValue(v), -1),
+        direction: -1,
+        earlyTerminate: false
+      }
+    },
+    primaryGt: {
+      asc: {
+        start: (tx, v) => tx.findUpperBoundLeaf(v[0]),
+        end: () => null,
+        direction: 1,
+        earlyTerminate: false
+      },
+      desc: {
+        start: (tx) => tx.rightestNode(),
+        end: (tx, v) => tx.findOuterBoundaryLeaf(v[0], -1),
+        direction: -1,
+        earlyTerminate: true
+      }
+    },
+    primaryGte: {
+      asc: {
+        start: (tx, v) => tx.findLowerBoundLeaf(v[0]),
+        end: () => null,
+        direction: 1,
+        earlyTerminate: false
+      },
+      desc: {
+        start: (tx) => tx.rightestNode(),
+        end: (tx, v) => tx.findOuterBoundaryLeaf(v[0], -1),
+        direction: -1,
+        earlyTerminate: true
+      }
+    },
+    primaryLt: {
+      asc: {
+        start: (tx) => tx.leftestNode(),
+        end: (tx, v) => tx.findOuterBoundaryLeaf(v[0], 1),
+        direction: 1,
+        earlyTerminate: true
+      },
+      desc: {
+        start: (tx, v) => tx.findLowerBoundLeaf(v[0]),
+        end: () => null,
+        direction: -1,
+        earlyTerminate: false
+      }
+    },
+    primaryLte: {
+      asc: {
+        start: (tx) => tx.leftestNode(),
+        end: (tx, v) => tx.findOuterBoundaryLeaf(v[0], 1),
+        direction: 1,
+        earlyTerminate: true
+      },
+      desc: {
+        start: (tx, v) => tx.findUpperBoundLeaf(v[0]),
+        end: () => null,
+        direction: -1,
+        earlyTerminate: false
+      }
+    },
+    primaryEqual: {
+      asc: {
+        start: (tx, v) => tx.findLowerBoundLeaf(v[0]),
+        end: (tx, v) => tx.findOuterBoundaryLeaf(v[0], 1),
+        direction: 1,
+        earlyTerminate: true
+      },
+      desc: {
+        start: (tx, v) => tx.findUpperBoundLeaf(v[0]),
+        end: (tx, v) => tx.findOuterBoundaryLeaf(v[0], -1),
+        direction: -1,
+        earlyTerminate: true
+      }
+    },
+    primaryNotEqual: {
+      asc: {
+        start: (tx) => tx.leftestNode(),
+        end: () => null,
+        direction: 1,
+        earlyTerminate: false
+      },
+      desc: {
+        start: (tx) => tx.rightestNode(),
+        end: () => null,
+        direction: -1,
+        earlyTerminate: false
+      }
+    },
+    primaryOr: {
+      asc: {
+        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.findUpperBoundLeaf(tx.highestPrimaryValue(v)),
+        end: (tx, v) => tx.findOuterBoundaryLeaf(tx.lowestPrimaryValue(v), -1),
+        direction: -1,
+        earlyTerminate: false
+      }
+    },
+    like: {
+      asc: {
+        start: (tx) => tx.leftestNode(),
+        end: () => null,
+        direction: 1,
+        earlyTerminate: false
+      },
+      desc: {
+        start: (tx) => tx.rightestNode(),
+        end: () => null,
+        direction: -1,
+        earlyTerminate: false
+      }
+    }
+  };
+  /**
+   * Priority map for condition types.
+   * Higher value = higher selectivity (fewer expected results).
+   * Used by `chooseDriver` to select the most selective index.
+   */
+  static conditionPriority = {
+    equal: 100,
+    primaryEqual: 100,
+    or: 80,
+    primaryOr: 80,
+    gt: 50,
+    gte: 50,
+    lt: 50,
+    lte: 50,
+    primaryGt: 50,
+    primaryGte: 50,
+    primaryLt: 50,
+    primaryLte: 50,
+    like: 30,
+    notEqual: 10,
+    primaryNotEqual: 10
+  };
+  /**
+   * Selects the best driver tree from multiple tree/condition pairs.
+   * Uses rule-based optimization to choose the tree with highest estimated selectivity.
+   * 
+   * @param candidates Array of { tree, condition } pairs to evaluate
+   * @returns The candidate with highest priority condition, or null if empty
+   * 
+   * @example
+   * ```typescript
+   * const driver = BPTreeSync.chooseDriver([
+   *   { tree: idxId, condition: { equal: 100 } },
+   *   { tree: idxAge, condition: { gt: 20 } }
+   * ])
+   * // Returns { tree: idxId, condition: { equal: 100 } } because 'equal' has higher priority
+   * ```
+   */
+  static ChooseDriver(candidates) {
+    if (candidates.length === 0) return null;
+    if (candidates.length === 1) return candidates[0];
+    let best = candidates[0];
+    let bestScore = 0;
+    for (const candidate of candidates) {
+      let score = 0;
+      for (const key in candidate.condition) {
+        const condKey = key;
+        const priority = _BPTreeTransaction.conditionPriority[condKey] ?? 0;
+        if (priority > score) {
+          score = priority;
+        }
+      }
+      if (score > bestScore) {
+        bestScore = score;
+        best = candidate;
+      }
+    }
+    return best;
+  }
+  /**
+   * Checks for conflicts between multiple transactions.
+   * 
+   * @param transactions Array of BPTreeTransaction instances to check
+   * @returns An array of keys that are in conflict. Empty array if no conflicts.
+   */
+  static CheckConflicts(transactions) {
+    return MVCCTransaction.CheckConflicts(transactions.map((tx) => tx.mvcc));
+  }
+  /**
+   * Returns the ID of the root node.
+   * @returns The root node ID.
+   */
+  getRootId() {
+    return this.rootId;
+  }
+  /**
+   * Returns the order of the B+Tree.
+   * @returns The order of the tree.
+   */
+  getOrder() {
+    return this.order;
+  }
+  /**
+   * Verified if the value satisfies the condition.
+   * 
+   * @param nodeValue The value to verify.
+   * @param condition The condition to verify against.
+   * @returns Returns true if the value satisfies the condition.
+   */
+  verify(nodeValue, condition) {
+    for (const key in condition) {
+      const verify2 = this.verifierMap[key];
+      const condValue = condition[key];
+      if (!verify2(nodeValue, condValue)) {
+        return false;
+      }
+    }
+    return true;
+  }
+  /**
+   * Inserts a key-value pair into an already-cloned leaf node in-place.
+   * Unlike _insertAtLeaf, this does NOT clone or update the node via MVCC.
+   * Used by batchInsert to batch multiple insertions with a single clone/update.
+   * @returns true if the leaf was modified, false if the key already exists.
+   */
+  _insertValueIntoLeaf(leaf, key, value) {
+    if (leaf.values.length) {
+      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;
+    }
+  }
+  _cloneNode(node) {
+    return JSON.parse(JSON.stringify(node));
+  }
+  /**
+   * Resolves the best start/end configuration by independently examining
+   * all conditions. Selects the tightest lower bound for start and the
+   * tightest upper bound for end (in asc; reversed for desc).
+   *
+   * @param condition The condition to analyze.
+   * @param order The sort order ('asc' or 'desc').
+   * @returns The resolved start/end keys, values, and traversal direction.
+   */
+  resolveStartEndConfigs(condition, order) {
+    const direction = order === "asc" ? 1 : -1;
+    const startCandidates = order === "asc" ? _BPTreeTransaction._lowerBoundKeys : _BPTreeTransaction._upperBoundKeys;
+    const endCandidates = order === "asc" ? _BPTreeTransaction._upperBoundKeys : _BPTreeTransaction._lowerBoundKeys;
+    let startKey = null;
+    let endKey = null;
+    let startValues = [];
     let endValues = [];
     for (let i = 0, len = startCandidates.length; i < len; i++) {
       const key = startCandidates[i];
@@ -2059,6 +3126,10 @@ var BPTreeTransaction = class _BPTreeTransaction {
 
 // src/transaction/BPTreeSyncTransaction.ts
 var BPTreeSyncTransaction = class extends BPTreeTransaction {
+  _ops;
+  _ctx;
+  _verifierMapCached;
+  _searchConfigsCached;
   constructor(rootTx, mvccRoot, mvcc, strategy, comparator, option) {
     super(
       rootTx,
@@ -2068,248 +3139,113 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
       comparator,
       option
     );
+    this._initAlgoContext();
+  }
+  _initAlgoContext() {
+    const mvcc = this.mvcc;
+    const strategy = this.strategy;
+    const self = this;
+    this._ops = {
+      getNode(id) {
+        return mvcc.read(id);
+      },
+      createNode(leaf, keys, values, parent = null, next = null, prev = null) {
+        const id = strategy.id(leaf);
+        const node = { id, keys, values, leaf, parent, next, prev };
+        mvcc.create(id, node);
+        return node;
+      },
+      updateNode(node) {
+        if (mvcc.isDeleted(node.id)) {
+          return;
+        }
+        mvcc.write(node.id, node);
+      },
+      deleteNode(node) {
+        if (mvcc.isDeleted(node.id)) {
+          return;
+        }
+        mvcc.delete(node.id);
+      },
+      readHead() {
+        return mvcc.read("__HEAD__");
+      },
+      writeHead(head) {
+        if (!mvcc.exists("__HEAD__")) {
+          mvcc.create("__HEAD__", head);
+        } else {
+          mvcc.write("__HEAD__", head);
+        }
+        self.rootId = head.root;
+      }
+    };
+    this._ctx = {
+      get rootId() {
+        return self.rootId;
+      },
+      set rootId(v) {
+        self.rootId = v;
+      },
+      get order() {
+        return self.order;
+      },
+      set order(v) {
+        self.order = v;
+      },
+      headData: () => this.strategy.head.data
+    };
+    const ensureValues = (v) => this.ensureValues(v);
+    this._verifierMapCached = createVerifierMap(this.comparator, this._cachedRegexp, ensureValues);
+    this._searchConfigsCached = createSearchConfigs(this.comparator, ensureValues);
   }
+  // ─── Legacy protected methods (delegating to ops) ────────────────
   getNode(id) {
-    return this.mvcc.read(id);
+    return this._ops.getNode(id);
   }
-  /**
-   * Create a new node with a unique ID.
-   */
   _createNode(leaf, keys, values, parent = null, next = null, prev = null) {
-    const id = this.strategy.id(leaf);
-    const node = {
-      id,
-      keys,
-      values,
-      leaf,
-      parent,
-      next,
-      prev
-    };
-    this.mvcc.create(id, node);
-    return node;
+    return this._ops.createNode(leaf, keys, values, parent, next, prev);
   }
   _updateNode(node) {
-    if (this.mvcc.isDeleted(node.id)) {
-      return;
-    }
-    this.mvcc.write(node.id, node);
+    this._ops.updateNode(node);
   }
   _deleteNode(node) {
-    if (this.mvcc.isDeleted(node.id)) {
-      return;
-    }
-    this.mvcc.delete(node.id);
+    this._ops.deleteNode(node);
   }
   _readHead() {
-    return this.mvcc.read("__HEAD__");
+    return this._ops.readHead();
   }
   _writeHead(head) {
-    if (!this.mvcc.exists("__HEAD__")) {
-      this.mvcc.create("__HEAD__", head);
-    } else {
-      this.mvcc.write("__HEAD__", head);
-    }
-    this.rootId = head.root;
+    this._ops.writeHead(head);
   }
+  // ─── Tree traversal (delegating to algorithm) ────────────────────
   _insertAtLeaf(node, key, value) {
-    let leaf = node;
-    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)) {
-          const keys = leaf.keys[i];
-          if (keys.includes(key)) {
-            break;
-          }
-          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);
-          return leaf;
-        }
-      }
-    } else {
-      leaf = this._cloneNode(leaf);
-      leaf.values = [value];
-      leaf.keys = [[key]];
-      this._updateNode(leaf);
-      return leaf;
-    }
-    return leaf;
+    return insertAtLeaf(this._ops, node, key, value, this.comparator);
   }
   _insertInParent(node, value, newSiblingNode) {
-    if (this.rootId === node.id) {
-      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;
-      newSiblingNode.parent = root.id;
-      if (newSiblingNode.leaf) {
-        node.next = newSiblingNode.id;
-        newSiblingNode.prev = node.id;
-      }
-      this._writeHead({
-        root: root.id,
-        order: this.order,
-        data: this.strategy.head.data
-      });
-      this._updateNode(node);
-      this._updateNode(newSiblingNode);
-      return;
-    }
-    const parentNode = this._cloneNode(this.getNode(node.parent));
-    const nodeIndex = parentNode.keys.indexOf(node.id);
-    if (nodeIndex === -1) {
-      throw new Error(`Node ${node.id} not found in parent ${parentNode.id}`);
-    }
-    parentNode.values.splice(nodeIndex, 0, value);
-    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;
-      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 = newSiblingNode.id;
-        this._updateNode(oldNext);
-      }
-    }
-    this._updateNode(parentNode);
-    this._updateNode(newSiblingNode);
-    if (parentNode.keys.length > this.order) {
-      const newSiblingNodeRecursive = this._createNode(false, [], []);
-      newSiblingNodeRecursive.parent = parentNode.parent;
-      const mid = Math.ceil(this.order / 2) - 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);
-      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);
-      }
-      this._updateNode(parentNode);
-      this._insertInParent(parentNode, midValue, newSiblingNodeRecursive);
-    }
+    insertInParent(this._ops, this._ctx, node, value, newSiblingNode);
   }
   locateLeaf(value) {
-    let node = this.getNode(this.rootId);
-    while (!node.leaf) {
-      const { index } = this._binarySearchValues(node.values, value, false, true);
-      node = this.getNode(node.keys[index]);
-    }
-    return node;
+    return locateLeaf(this._ops, this._ctx.rootId, value, this.comparator);
   }
   findLowerBoundLeaf(value) {
-    let node = this.getNode(this.rootId);
-    while (!node.leaf) {
-      const { index } = this._binarySearchValues(node.values, value, true, false);
-      node = this.getNode(node.keys[index]);
-    }
-    return node;
+    return findLowerBoundLeaf(this._ops, this._ctx.rootId, value, this.comparator);
   }
   findUpperBoundLeaf(value) {
-    let node = this.getNode(this.rootId);
-    while (!node.leaf) {
-      const { index } = this._binarySearchValues(node.values, value, true, true);
-      node = this.getNode(node.keys[index]);
-    }
-    return node;
+    return findUpperBoundLeaf(this._ops, this._ctx.rootId, value, this.comparator);
   }
   findOuterBoundaryLeaf(value, direction) {
-    const insertableNode = direction === -1 ? this.findLowerBoundLeaf(value) : this.findUpperBoundLeaf(value);
-    let key;
-    switch (direction) {
-      case -1:
-        key = "prev";
-        break;
-      case 1:
-        key = "next";
-        break;
-      default:
-        throw new Error(`Direction must be -1 or 1. but got a ${direction}`);
-    }
-    const guessNode = insertableNode[key];
-    if (!guessNode) {
-      return null;
-    }
-    return this.getNode(guessNode);
+    return findOuterBoundaryLeaf(this._ops, this._ctx.rootId, value, direction, this.comparator);
   }
   leftestNode() {
-    let node = this.getNode(this.rootId);
-    if (node === null) {
-      debugger;
-    }
-    while (!node.leaf) {
-      const keys = node.keys;
-      node = this.getNode(keys[0]);
-    }
-    return node;
+    return leftestNode(this._ops, this._ctx.rootId);
   }
   rightestNode() {
-    let node = this.getNode(this.rootId);
-    while (!node.leaf) {
-      const keys = node.keys;
-      node = this.getNode(keys[keys.length - 1]);
-    }
-    return node;
+    return rightestNode(this._ops, this._ctx.rootId);
   }
   *getPairsGenerator(startNode, endNode, direction) {
-    let node = startNode;
-    while (true) {
-      if (endNode && node.id === endNode.id) {
-        break;
-      }
-      const len = node.values.length;
-      if (direction === 1) {
-        for (let i = 0; i < len; i++) {
-          const nValue = node.values[i];
-          const keys = node.keys[i];
-          for (let j = 0, len2 = keys.length; j < len2; j++) {
-            yield [keys[j], nValue];
-          }
-        }
-      } else {
-        let i = len;
-        while (i--) {
-          const nValue = node.values[i];
-          const keys = node.keys[i];
-          let j = keys.length;
-          while (j--) {
-            yield [keys[j], nValue];
-          }
-        }
-      }
-      if (direction === 1) {
-        if (!node.next) break;
-        node = this.getNode(node.next);
-      } else {
-        if (!node.prev) break;
-        node = this.getNode(node.prev);
-      }
-    }
+    yield* getPairsGenerator(this._ops, startNode, endNode, direction);
   }
+  // ─── Lifecycle ───────────────────────────────────────────────────
   init() {
     if (this.rootTx !== this) {
       throw new Error("Cannot call init on a nested transaction");
@@ -2326,24 +3262,15 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
     this.isInitialized = true;
     try {
       this._clearCache();
-      const head = this._readHead();
-      if (head === null) {
-        this.order = this.strategy.order;
-        const root = this._createNode(true, [], []);
-        this._writeHead({
-          root: root.id,
-          order: this.order,
-          data: this.strategy.head.data
-        });
-      } else {
-        const { root, order } = head;
-        this.strategy.head = head;
-        this.order = order;
-        this.rootId = root;
-      }
-      if (this.order < 3) {
-        throw new Error(`The 'order' parameter must be greater than 2. but got a '${this.order}'.`);
-      }
+      initOp(
+        this._ops,
+        this._ctx,
+        this.strategy.order,
+        this.strategy.head,
+        (head) => {
+          this.strategy.head = head;
+        }
+      );
     } catch (e) {
       this.isInitialized = false;
       throw e;
@@ -2359,501 +3286,68 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
     this._resetForReload();
     this._initInternal();
   }
+  // ─── Query (delegating to algorithm) ─────────────────────────────
   exists(key, value) {
-    const node = this.locateLeaf(value);
-    const { index, found } = this._binarySearchValues(node.values, value);
-    if (found) {
-      const keys = node.keys[index];
-      if (keys.includes(key)) {
-        return true;
-      }
-    }
-    return false;
+    return existsOp(this._ops, this._ctx.rootId, key, value, this.comparator);
   }
   get(key) {
-    let node = this.leftestNode();
-    while (true) {
-      for (let i = 0, len = node.values.length; i < len; i++) {
-        const keys = node.keys[i];
-        for (let j = 0, len2 = keys.length; j < len2; j++) {
-          if (keys[j] === key) {
-            return node.values[i];
-          }
-        }
-      }
-      if (!node.next) break;
-      node = this.getNode(node.next);
-    }
-    return void 0;
+    return getOp(this._ops, this._ctx.rootId, key);
   }
   *keysStream(condition, options) {
-    const { filterValues, limit, order = "asc" } = options ?? {};
-    const stream = this.whereStream(condition, options);
-    const intersection = filterValues && filterValues.size > 0 ? filterValues : null;
-    let count = 0;
-    for (const [key] of stream) {
-      if (intersection && !intersection.has(key)) {
-        continue;
-      }
-      yield key;
-      count++;
-      if (limit !== void 0 && count >= limit) {
-        break;
-      }
-    }
+    yield* keysStreamOp(
+      this._ops,
+      this._ctx.rootId,
+      condition,
+      this.comparator,
+      this._verifierMapCached,
+      this._searchConfigsCached,
+      this.ensureValues.bind(this),
+      options
+    );
   }
   *whereStream(condition, options) {
-    const { filterValues, limit, order = "asc" } = options ?? {};
-    const conditionKeys = Object.keys(condition);
-    if (conditionKeys.length === 0) return;
-    const resolved = this.resolveStartEndConfigs(condition, order);
-    const direction = resolved.direction;
-    let startNode;
-    if (resolved.startKey) {
-      const startConfig = this.searchConfigs[resolved.startKey][order];
-      startNode = startConfig.start(this, resolved.startValues);
-    } else {
-      startNode = order === "asc" ? this.leftestNode() : this.rightestNode();
-    }
-    let endNode = null;
-    if (resolved.endKey) {
-      const endConfig = this.searchConfigs[resolved.endKey][order];
-      endNode = endConfig.end(this, resolved.endValues);
-    }
-    if (!startNode) return;
-    const generator = this.getPairsGenerator(
-      startNode,
-      endNode,
-      direction
+    yield* whereStreamOp(
+      this._ops,
+      this._ctx.rootId,
+      condition,
+      this.comparator,
+      this._verifierMapCached,
+      this._searchConfigsCached,
+      this.ensureValues.bind(this),
+      options
     );
-    let count = 0;
-    const intersection = filterValues && filterValues.size > 0 ? filterValues : null;
-    for (const pair of generator) {
-      const [k, v] = pair;
-      if (intersection && !intersection.has(k)) {
-        continue;
-      }
-      if (this.verify(v, condition)) {
-        yield pair;
-        count++;
-        if (limit !== void 0 && count >= limit) {
-          break;
-        }
-      }
-    }
   }
   keys(condition, options) {
     const set = /* @__PURE__ */ new Set();
     for (const key of this.keysStream(condition, options)) {
-      set.add(key);
-    }
-    return set;
-  }
-  where(condition, options) {
-    const map = /* @__PURE__ */ new Map();
-    for (const [key, value] of this.whereStream(condition, options)) {
-      map.set(key, value);
-    }
-    return map;
-  }
-  insert(key, value) {
-    let before = this.locateLeaf(value);
-    before = this._insertAtLeaf(before, key, value);
-    if (before.values.length === this.order) {
-      let after = this._createNode(
-        true,
-        [],
-        [],
-        before.parent,
-        null,
-        null
-      );
-      const mid = Math.ceil(this.order / 2) - 1;
-      after = this._cloneNode(after);
-      after.values = before.values.slice(mid + 1);
-      after.keys = before.keys.slice(mid + 1);
-      before.values = before.values.slice(0, mid + 1);
-      before.keys = before.keys.slice(0, mid + 1);
-      this._updateNode(before);
-      this._updateNode(after);
-      this._insertInParent(before, after.values[0], after);
-    }
-  }
-  batchInsert(entries) {
-    if (entries.length === 0) return;
-    const sorted = [...entries].sort((a, b) => this.comparator.asc(a[1], b[1]));
-    let currentLeaf = null;
-    let modified = false;
-    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) {
-          this._updateNode(currentLeaf);
-        }
-        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(
-          true,
-          [],
-          [],
-          currentLeaf.parent,
-          null,
-          null
-        );
-        const mid = Math.ceil(this.order / 2) - 1;
-        after = this._cloneNode(after);
-        after.values = currentLeaf.values.slice(mid + 1);
-        after.keys = currentLeaf.keys.slice(mid + 1);
-        currentLeaf.values = currentLeaf.values.slice(0, mid + 1);
-        currentLeaf.keys = currentLeaf.keys.slice(0, mid + 1);
-        this._updateNode(currentLeaf);
-        this._updateNode(after);
-        this._insertInParent(currentLeaf, after.values[0], after);
-        currentLeaf = null;
-        cachedLeafId = null;
-        cachedLeafMaxValue = null;
-        modified = false;
-      }
-    }
-    if (currentLeaf !== null && modified) {
-      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;
-      for (let i = 0, len = node.keys.length; i < len; i++) {
-        if (node.keys[i] === key) {
-          keyIndex = i;
-          break;
-        }
-      }
-      if (keyIndex !== -1) {
-        node = this._cloneNode(node);
-        node.keys.splice(keyIndex, 1);
-        const valueIndex = keyIndex > 0 ? keyIndex - 1 : 0;
-        node.values.splice(valueIndex, 1);
-        this._updateNode(node);
-      }
-    }
-    if (this.rootId === node.id && node.keys.length === 1 && !node.leaf) {
-      const keys = node.keys;
-      this._deleteNode(node);
-      const newRoot = this._cloneNode(this.getNode(keys[0]));
-      newRoot.parent = null;
-      this._updateNode(newRoot);
-      this._writeHead({
-        root: newRoot.id,
-        order: this.order,
-        data: this.strategy.head.data
-      });
-      return node;
-    } else if (this.rootId === node.id) {
-      this._writeHead({
-        root: node.id,
-        order: this.order,
-        data: this.strategy.head.data
-      });
-      return node;
-    } else if (node.keys.length < Math.ceil(this.order / 2) && !node.leaf || node.values.length < Math.ceil((this.order - 1) / 2) && node.leaf) {
-      if (node.parent === null) {
-        return node;
-      }
-      let isPredecessor = false;
-      let parentNode = this.getNode(node.parent);
-      let prevNode = null;
-      let nextNode = null;
-      let prevValue = null;
-      let postValue = null;
-      for (let i = 0, len = parentNode.keys.length; i < len; i++) {
-        const nKey = parentNode.keys[i];
-        if (nKey === node.id) {
-          if (i > 0) {
-            prevNode = this.getNode(parentNode.keys[i - 1]);
-            prevValue = parentNode.values[i - 1];
-          }
-          if (i < parentNode.keys.length - 1) {
-            nextNode = this.getNode(parentNode.keys[i + 1]);
-            postValue = parentNode.values[i];
-          }
-        }
-      }
-      let siblingNode;
-      let guess;
-      if (prevNode === null) {
-        siblingNode = nextNode;
-        guess = postValue;
-      } else if (nextNode === null) {
-        isPredecessor = true;
-        siblingNode = prevNode;
-        guess = prevValue;
-      } else {
-        if (node.values.length + nextNode.values.length < this.order) {
-          siblingNode = nextNode;
-          guess = postValue;
-        } else {
-          isPredecessor = true;
-          siblingNode = prevNode;
-          guess = prevValue;
-        }
-      }
-      if (!siblingNode) {
-        return node;
-      }
-      node = this._cloneNode(node);
-      siblingNode = this._cloneNode(siblingNode);
-      if (node.values.length + siblingNode.values.length < this.order) {
-        if (!isPredecessor) {
-          const pTemp = siblingNode;
-          siblingNode = node;
-          node = pTemp;
-        }
-        siblingNode.keys.push(...node.keys);
-        if (!node.leaf) {
-          siblingNode.values.push(guess);
-        } else {
-          siblingNode.next = node.next;
-          if (siblingNode.next) {
-            const n = this._cloneNode(this.getNode(siblingNode.next));
-            n.prev = siblingNode.id;
-            this._updateNode(n);
-          }
-        }
-        siblingNode.values.push(...node.values);
-        if (!siblingNode.leaf) {
-          const keys = siblingNode.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);
-          }
-        }
-        this._deleteNode(node);
-        this._updateNode(siblingNode);
-        this._deleteEntry(this.getNode(node.parent), node.id);
-      } else {
-        if (isPredecessor) {
-          let pointerPm;
-          let pointerKm;
-          if (!node.leaf) {
-            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));
-            const nodeIndex = parentNode.keys.indexOf(node.id);
-            if (nodeIndex > 0) {
-              parentNode.values[nodeIndex - 1] = pointerKm;
-              this._updateNode(parentNode);
-            }
-          } else {
-            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));
-            const nodeIndex = parentNode.keys.indexOf(node.id);
-            if (nodeIndex > 0) {
-              parentNode.values[nodeIndex - 1] = pointerKm;
-              this._updateNode(parentNode);
-            }
-          }
-          this._updateNode(node);
-          this._updateNode(siblingNode);
-        } else {
-          let pointerP0;
-          let pointerK0;
-          if (!node.leaf) {
-            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(siblingNode.id);
-            if (pointerIndex > 0) {
-              parentNode.values[pointerIndex - 1] = pointerK0;
-              this._updateNode(parentNode);
-            }
-          } else {
-            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(siblingNode.id);
-            if (pointerIndex > 0) {
-              parentNode.values[pointerIndex - 1] = siblingNode.values[0];
-              this._updateNode(parentNode);
-            }
-          }
-          this._updateNode(node);
-          this._updateNode(siblingNode);
-        }
-        if (!siblingNode.leaf) {
-          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 (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 (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);
-          }
-        }
-      }
-    } else {
-      this._updateNode(this._cloneNode(node));
+      set.add(key);
     }
-    return node;
+    return set;
   }
-  delete(key, value) {
-    if (value === void 0) {
-      value = this.get(key);
-    }
-    if (value === void 0) {
-      return;
-    }
-    let node = this.findLowerBoundLeaf(value);
-    let found = false;
-    while (true) {
-      let i = node.values.length;
-      while (i--) {
-        const nValue = node.values[i];
-        if (this.comparator.isSame(value, nValue)) {
-          const keys = node.keys[i];
-          const keyIndex = keys.indexOf(key);
-          if (keyIndex !== -1) {
-            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);
-            }
-            this._updateNode(node);
-            node = this._deleteEntry(node, key);
-            found = true;
-            break;
-          }
-        }
-      }
-      if (found) break;
-      if (node.next) {
-        node = this.getNode(node.next);
-        continue;
-      }
-      break;
+  where(condition, options) {
+    const map = /* @__PURE__ */ new Map();
+    for (const [key, value] of this.whereStream(condition, options)) {
+      map.set(key, value);
     }
+    return map;
+  }
+  // ─── Mutation (delegating to algorithm) ──────────────────────────
+  insert(key, value) {
+    insertOp(this._ops, this._ctx, key, value, this.comparator);
+  }
+  batchInsert(entries) {
+    batchInsertOp(this._ops, this._ctx, entries, this.comparator);
+  }
+  bulkLoad(entries) {
+    bulkLoadOp(this._ops, this._ctx, entries, this.comparator);
+  }
+  _deleteEntry(node, key) {
+    return deleteEntry(this._ops, this._ctx, node, key, this.comparator);
+  }
+  delete(key, value) {
+    deleteOp(this._ops, this._ctx, key, this.comparator, value);
   }
+  // ─── Head Data ───────────────────────────────────────────────────
   getHeadData() {
     const head = this._readHead();
     if (head === null) {
@@ -2872,6 +3366,7 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
       data
     });
   }
+  // ─── Transaction ─────────────────────────────────────────────────
   commit(label) {
     let result = this.mvcc.commit(label);
     if (result.success) {
@@ -3226,36 +3721,843 @@ var Ryoiki2 = class _Ryoiki2 {
         rangeTask: [Array, Function],
         rangeTaskTimeout: [Array, Function, Number]
       }
-    );
-    return this._lock(
-      this.writeQueue,
-      range,
-      timeout,
-      task,
-      () => {
-        return !this.rangeOverlapping(this.writings, range) && !this.rangeOverlapping(this.readings, range);
+    );
+    return this._lock(
+      this.writeQueue,
+      range,
+      timeout,
+      task,
+      () => {
+        return !this.rangeOverlapping(this.writings, range) && !this.rangeOverlapping(this.readings, range);
+      }
+    );
+  }
+  /**
+   * Releases a read lock by its lock ID.
+   * @param lockId - The unique identifier for the lock to release.
+   */
+  readUnlock(lockId) {
+    this._free(this.readings, lockId);
+  }
+  /**
+   * Releases a write lock by its lock ID.
+   * @param lockId - The unique identifier for the lock to release.
+   */
+  writeUnlock(lockId) {
+    this._free(this.writings, lockId);
+  }
+};
+
+// src/base/BPTreeAlgorithmAsync.ts
+function createSearchConfigsAsync(comparator, ensureValues) {
+  const lowest = (v) => [...v].sort((a, b) => comparator.asc(a, b))[0];
+  const highest = (v) => [...v].sort((a, b) => comparator.asc(a, b))[v.length - 1];
+  const lowestPrimary = (v) => [...v].sort((a, b) => comparator.primaryAsc(a, b))[0];
+  const highestPrimary = (v) => [...v].sort((a, b) => comparator.primaryAsc(a, b))[v.length - 1];
+  return {
+    gt: {
+      asc: {
+        start: (r, ops, v) => findUpperBoundLeafAsync(ops, r, v[0], comparator),
+        end: async () => null,
+        direction: 1,
+        earlyTerminate: false
+      },
+      desc: {
+        start: (r, ops) => rightestNodeAsync(ops, r),
+        end: (r, ops, v) => findOuterBoundaryLeafAsync(ops, r, v[0], -1, comparator),
+        direction: -1,
+        earlyTerminate: true
+      }
+    },
+    gte: {
+      asc: {
+        start: (r, ops, v) => findLowerBoundLeafAsync(ops, r, v[0], comparator),
+        end: async () => null,
+        direction: 1,
+        earlyTerminate: false
+      },
+      desc: {
+        start: (r, ops) => rightestNodeAsync(ops, r),
+        end: (r, ops, v) => findOuterBoundaryLeafAsync(ops, r, v[0], -1, comparator),
+        direction: -1,
+        earlyTerminate: true
+      }
+    },
+    lt: {
+      asc: {
+        start: (r, ops) => leftestNodeAsync(ops, r),
+        end: (r, ops, v) => findOuterBoundaryLeafAsync(ops, r, v[0], 1, comparator),
+        direction: 1,
+        earlyTerminate: true
+      },
+      desc: {
+        start: (r, ops, v) => findLowerBoundLeafAsync(ops, r, v[0], comparator),
+        end: async () => null,
+        direction: -1,
+        earlyTerminate: false
+      }
+    },
+    lte: {
+      asc: {
+        start: (r, ops) => leftestNodeAsync(ops, r),
+        end: (r, ops, v) => findOuterBoundaryLeafAsync(ops, r, v[0], 1, comparator),
+        direction: 1,
+        earlyTerminate: true
+      },
+      desc: {
+        start: (r, ops, v) => findUpperBoundLeafAsync(ops, r, v[0], comparator),
+        end: async () => null,
+        direction: -1,
+        earlyTerminate: false
+      }
+    },
+    equal: {
+      asc: {
+        start: (r, ops, v) => findLowerBoundLeafAsync(ops, r, v[0], comparator),
+        end: (r, ops, v) => findOuterBoundaryLeafAsync(ops, r, v[0], 1, comparator),
+        direction: 1,
+        earlyTerminate: true
+      },
+      desc: {
+        start: (r, ops, v) => findOuterBoundaryLeafAsync(ops, r, v[0], 1, comparator),
+        end: (r, ops, v) => findOuterBoundaryLeafAsync(ops, r, v[0], -1, comparator),
+        direction: -1,
+        earlyTerminate: true
+      }
+    },
+    notEqual: {
+      asc: {
+        start: (r, ops) => leftestNodeAsync(ops, r),
+        end: async () => null,
+        direction: 1,
+        earlyTerminate: false
+      },
+      desc: {
+        start: (r, ops) => rightestNodeAsync(ops, r),
+        end: async () => null,
+        direction: -1,
+        earlyTerminate: false
+      }
+    },
+    or: {
+      asc: {
+        start: (r, ops, v) => findLowerBoundLeafAsync(ops, r, lowest(ensureValues(v)), comparator),
+        end: (r, ops, v) => findOuterBoundaryLeafAsync(ops, r, highest(ensureValues(v)), 1, comparator),
+        direction: 1,
+        earlyTerminate: false
+      },
+      desc: {
+        start: (r, ops, v) => findOuterBoundaryLeafAsync(ops, r, highest(ensureValues(v)), 1, comparator),
+        end: (r, ops, v) => findOuterBoundaryLeafAsync(ops, r, lowest(ensureValues(v)), -1, comparator),
+        direction: -1,
+        earlyTerminate: false
+      }
+    },
+    primaryGt: {
+      asc: {
+        start: (r, ops, v) => findUpperBoundLeafAsync(ops, r, v[0], comparator),
+        end: async () => null,
+        direction: 1,
+        earlyTerminate: false
+      },
+      desc: {
+        start: (r, ops) => rightestNodeAsync(ops, r),
+        end: (r, ops, v) => findOuterBoundaryLeafAsync(ops, r, v[0], -1, comparator),
+        direction: -1,
+        earlyTerminate: true
+      }
+    },
+    primaryGte: {
+      asc: {
+        start: (r, ops, v) => findLowerBoundLeafAsync(ops, r, v[0], comparator),
+        end: async () => null,
+        direction: 1,
+        earlyTerminate: false
+      },
+      desc: {
+        start: (r, ops) => rightestNodeAsync(ops, r),
+        end: (r, ops, v) => findOuterBoundaryLeafAsync(ops, r, v[0], -1, comparator),
+        direction: -1,
+        earlyTerminate: true
+      }
+    },
+    primaryLt: {
+      asc: {
+        start: (r, ops) => leftestNodeAsync(ops, r),
+        end: (r, ops, v) => findOuterBoundaryLeafAsync(ops, r, v[0], 1, comparator),
+        direction: 1,
+        earlyTerminate: true
+      },
+      desc: {
+        start: (r, ops, v) => findLowerBoundLeafAsync(ops, r, v[0], comparator),
+        end: async () => null,
+        direction: -1,
+        earlyTerminate: false
+      }
+    },
+    primaryLte: {
+      asc: {
+        start: (r, ops) => leftestNodeAsync(ops, r),
+        end: (r, ops, v) => findOuterBoundaryLeafAsync(ops, r, v[0], 1, comparator),
+        direction: 1,
+        earlyTerminate: true
+      },
+      desc: {
+        start: (r, ops, v) => findUpperBoundLeafAsync(ops, r, v[0], comparator),
+        end: async () => null,
+        direction: -1,
+        earlyTerminate: false
+      }
+    },
+    primaryEqual: {
+      asc: {
+        start: (r, ops, v) => findLowerBoundLeafAsync(ops, r, v[0], comparator),
+        end: (r, ops, v) => findOuterBoundaryLeafAsync(ops, r, v[0], 1, comparator),
+        direction: 1,
+        earlyTerminate: true
+      },
+      desc: {
+        start: (r, ops, v) => findUpperBoundLeafAsync(ops, r, v[0], comparator),
+        end: (r, ops, v) => findOuterBoundaryLeafAsync(ops, r, v[0], -1, comparator),
+        direction: -1,
+        earlyTerminate: true
+      }
+    },
+    primaryNotEqual: {
+      asc: {
+        start: (r, ops) => leftestNodeAsync(ops, r),
+        end: async () => null,
+        direction: 1,
+        earlyTerminate: false
+      },
+      desc: {
+        start: (r, ops) => rightestNodeAsync(ops, r),
+        end: async () => null,
+        direction: -1,
+        earlyTerminate: false
+      }
+    },
+    primaryOr: {
+      asc: {
+        start: (r, ops, v) => findLowerBoundLeafAsync(ops, r, lowestPrimary(ensureValues(v)), comparator),
+        end: (r, ops, v) => findOuterBoundaryLeafAsync(ops, r, highestPrimary(ensureValues(v)), 1, comparator),
+        direction: 1,
+        earlyTerminate: false
+      },
+      desc: {
+        start: (r, ops, v) => findUpperBoundLeafAsync(ops, r, highestPrimary(ensureValues(v)), comparator),
+        end: (r, ops, v) => findOuterBoundaryLeafAsync(ops, r, lowestPrimary(ensureValues(v)), -1, comparator),
+        direction: -1,
+        earlyTerminate: false
+      }
+    },
+    like: {
+      asc: {
+        start: (r, ops) => leftestNodeAsync(ops, r),
+        end: async () => null,
+        direction: 1,
+        earlyTerminate: false
+      },
+      desc: {
+        start: (r, ops) => rightestNodeAsync(ops, r),
+        end: async () => null,
+        direction: -1,
+        earlyTerminate: false
+      }
+    }
+  };
+}
+async function locateLeafAsync(ops, rootId, value, comparator) {
+  let node = await ops.getNode(rootId);
+  while (!node.leaf) {
+    const { index } = binarySearchValues(node.values, value, comparator, false, true);
+    node = await ops.getNode(node.keys[index]);
+  }
+  return node;
+}
+async function findLowerBoundLeafAsync(ops, rootId, value, comparator) {
+  let node = await ops.getNode(rootId);
+  while (!node.leaf) {
+    const { index } = binarySearchValues(node.values, value, comparator, true, false);
+    node = await ops.getNode(node.keys[index]);
+  }
+  return node;
+}
+async function findUpperBoundLeafAsync(ops, rootId, value, comparator) {
+  let node = await ops.getNode(rootId);
+  while (!node.leaf) {
+    const { index } = binarySearchValues(node.values, value, comparator, true, true);
+    node = await ops.getNode(node.keys[index]);
+  }
+  return node;
+}
+async function findOuterBoundaryLeafAsync(ops, rootId, value, direction, comparator) {
+  const insertableNode = direction === -1 ? await findLowerBoundLeafAsync(ops, rootId, value, comparator) : await findUpperBoundLeafAsync(ops, rootId, value, comparator);
+  const key = direction === -1 ? "prev" : "next";
+  const guessNode = insertableNode[key];
+  if (!guessNode) return null;
+  return await ops.getNode(guessNode);
+}
+async function leftestNodeAsync(ops, rootId) {
+  let node = await ops.getNode(rootId);
+  while (!node.leaf) {
+    node = await ops.getNode(node.keys[0]);
+  }
+  return node;
+}
+async function rightestNodeAsync(ops, rootId) {
+  let node = await ops.getNode(rootId);
+  while (!node.leaf) {
+    node = await ops.getNode(node.keys[node.keys.length - 1]);
+  }
+  return node;
+}
+async function* getPairsGeneratorAsync(ops, startNode, endNode, direction) {
+  let node = startNode;
+  let nextNodePromise = null;
+  while (true) {
+    if (endNode && node.id === endNode.id) break;
+    if (direction === 1) {
+      if (node.next) nextNodePromise = ops.getNode(node.next);
+    } else {
+      if (node.prev) nextNodePromise = ops.getNode(node.prev);
+    }
+    const len = node.values.length;
+    if (direction === 1) {
+      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++) {
+          yield [keys[j], nValue];
+        }
+      }
+    } else {
+      let i = len;
+      while (i--) {
+        const nValue = node.values[i];
+        const keys = node.keys[i];
+        let j = keys.length;
+        while (j--) {
+          yield [keys[j], nValue];
+        }
+      }
+    }
+    if (nextNodePromise) {
+      node = await nextNodePromise;
+      nextNodePromise = null;
+    } else {
+      break;
+    }
+  }
+}
+async function insertAtLeafAsync(ops, node, key, value, comparator) {
+  let leaf = node;
+  if (leaf.values.length) {
+    for (let i = 0, len = leaf.values.length; i < len; i++) {
+      const nValue = leaf.values[i];
+      if (comparator.isSame(value, nValue)) {
+        if (leaf.keys[i].includes(key)) break;
+        leaf = cloneNode(leaf);
+        leaf.keys[i].push(key);
+        await ops.updateNode(leaf);
+        return leaf;
+      } else if (comparator.isLower(value, nValue)) {
+        leaf = cloneNode(leaf);
+        leaf.values.splice(i, 0, value);
+        leaf.keys.splice(i, 0, [key]);
+        await ops.updateNode(leaf);
+        return leaf;
+      } else if (i + 1 === leaf.values.length) {
+        leaf = cloneNode(leaf);
+        leaf.values.push(value);
+        leaf.keys.push([key]);
+        await ops.updateNode(leaf);
+        return leaf;
+      }
+    }
+  } else {
+    leaf = cloneNode(leaf);
+    leaf.values = [value];
+    leaf.keys = [[key]];
+    await ops.updateNode(leaf);
+    return leaf;
+  }
+  return leaf;
+}
+async function insertInParentAsync(ops, ctx, node, value, newSiblingNode) {
+  if (ctx.rootId === node.id) {
+    node = cloneNode(node);
+    newSiblingNode = cloneNode(newSiblingNode);
+    const root = await ops.createNode(false, [node.id, newSiblingNode.id], [value]);
+    ctx.rootId = root.id;
+    node.parent = root.id;
+    newSiblingNode.parent = root.id;
+    if (newSiblingNode.leaf) {
+      ;
+      node.next = newSiblingNode.id;
+      newSiblingNode.prev = node.id;
+    }
+    await ops.writeHead({ root: root.id, order: ctx.order, data: ctx.headData() });
+    await ops.updateNode(node);
+    await ops.updateNode(newSiblingNode);
+    return;
+  }
+  const parentNode = cloneNode(await ops.getNode(node.parent));
+  const nodeIndex = parentNode.keys.indexOf(node.id);
+  if (nodeIndex === -1) throw new Error(`Node ${node.id} not found in parent ${parentNode.id}`);
+  parentNode.values.splice(nodeIndex, 0, value);
+  parentNode.keys.splice(nodeIndex + 1, 0, newSiblingNode.id);
+  newSiblingNode = cloneNode(newSiblingNode);
+  newSiblingNode.parent = parentNode.id;
+  if (newSiblingNode.leaf) {
+    const leftSibling = cloneNode(node);
+    const oldNextId = leftSibling.next;
+    newSiblingNode.prev = leftSibling.id;
+    newSiblingNode.next = oldNextId;
+    leftSibling.next = newSiblingNode.id;
+    await ops.updateNode(leftSibling);
+    if (oldNextId) {
+      const oldNext = cloneNode(await ops.getNode(oldNextId));
+      oldNext.prev = newSiblingNode.id;
+      await ops.updateNode(oldNext);
+    }
+  }
+  await ops.updateNode(parentNode);
+  await ops.updateNode(newSiblingNode);
+  if (parentNode.keys.length > ctx.order) {
+    const rec = await ops.createNode(false, [], []);
+    rec.parent = parentNode.parent;
+    const mid = Math.ceil(ctx.order / 2) - 1;
+    rec.values = parentNode.values.slice(mid + 1);
+    rec.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);
+    for (let i = 0, len = rec.keys.length; i < len; i++) {
+      const n = cloneNode(await ops.getNode(rec.keys[i]));
+      n.parent = rec.id;
+      await ops.updateNode(n);
+    }
+    await ops.updateNode(parentNode);
+    await insertInParentAsync(ops, ctx, parentNode, midValue, rec);
+  }
+}
+async function insertOpAsync(ops, ctx, key, value, comparator) {
+  let before = await locateLeafAsync(ops, ctx.rootId, value, comparator);
+  before = await insertAtLeafAsync(ops, before, key, value, comparator);
+  if (before.values.length === ctx.order) {
+    let after = await ops.createNode(true, [], [], before.parent, null, null);
+    const mid = Math.ceil(ctx.order / 2) - 1;
+    after = cloneNode(after);
+    after.values = before.values.slice(mid + 1);
+    after.keys = before.keys.slice(mid + 1);
+    before.values = before.values.slice(0, mid + 1);
+    before.keys = before.keys.slice(0, mid + 1);
+    await ops.updateNode(before);
+    await ops.updateNode(after);
+    await insertInParentAsync(ops, ctx, before, after.values[0], after);
+  }
+}
+async function deleteEntryAsync(ops, ctx, node, key, comparator) {
+  if (!node.leaf) {
+    let keyIndex = -1;
+    for (let i = 0, len = node.keys.length; i < len; i++) {
+      if (node.keys[i] === key) {
+        keyIndex = i;
+        break;
+      }
+    }
+    if (keyIndex !== -1) {
+      node = cloneNode(node);
+      node.keys.splice(keyIndex, 1);
+      const valueIndex = keyIndex > 0 ? keyIndex - 1 : 0;
+      node.values.splice(valueIndex, 1);
+      await ops.updateNode(node);
+    }
+  }
+  if (ctx.rootId === node.id && node.keys.length === 1 && !node.leaf) {
+    const keys = node.keys;
+    await ops.deleteNode(node);
+    const newRoot = cloneNode(await ops.getNode(keys[0]));
+    newRoot.parent = null;
+    await ops.updateNode(newRoot);
+    await ops.writeHead({ root: newRoot.id, order: ctx.order, data: ctx.headData() });
+    ctx.rootId = newRoot.id;
+    return node;
+  } else if (ctx.rootId === node.id) {
+    await ops.writeHead({ root: node.id, order: ctx.order, data: ctx.headData() });
+    return node;
+  } else if (node.keys.length < Math.ceil(ctx.order / 2) && !node.leaf || node.values.length < Math.ceil((ctx.order - 1) / 2) && node.leaf) {
+    if (node.parent === null) return node;
+    let isPredecessor = false;
+    let parentNode = await ops.getNode(node.parent);
+    let prevNode = null;
+    let nextNode = null;
+    let prevValue = null;
+    let postValue = null;
+    for (let i = 0, len = parentNode.keys.length; i < len; i++) {
+      if (parentNode.keys[i] === node.id) {
+        if (i > 0) {
+          prevNode = await ops.getNode(parentNode.keys[i - 1]);
+          prevValue = parentNode.values[i - 1];
+        }
+        if (i < parentNode.keys.length - 1) {
+          nextNode = await ops.getNode(parentNode.keys[i + 1]);
+          postValue = parentNode.values[i];
+        }
+      }
+    }
+    let siblingNode;
+    let guess;
+    if (prevNode === null) {
+      siblingNode = nextNode;
+      guess = postValue;
+    } else if (nextNode === null) {
+      isPredecessor = true;
+      siblingNode = prevNode;
+      guess = prevValue;
+    } else {
+      if (node.values.length + nextNode.values.length < ctx.order) {
+        siblingNode = nextNode;
+        guess = postValue;
+      } else {
+        isPredecessor = true;
+        siblingNode = prevNode;
+        guess = prevValue;
+      }
+    }
+    if (!siblingNode) return node;
+    node = cloneNode(node);
+    siblingNode = cloneNode(siblingNode);
+    if (node.values.length + siblingNode.values.length < ctx.order) {
+      if (!isPredecessor) {
+        const t = siblingNode;
+        siblingNode = node;
+        node = t;
+      }
+      siblingNode.keys.push(...node.keys);
+      if (!node.leaf) {
+        siblingNode.values.push(guess);
+      } else {
+        siblingNode.next = node.next;
+        if (siblingNode.next) {
+          const n = cloneNode(await ops.getNode(siblingNode.next));
+          n.prev = siblingNode.id;
+          await ops.updateNode(n);
+        }
+      }
+      siblingNode.values.push(...node.values);
+      if (!siblingNode.leaf) {
+        for (let i = 0, len = siblingNode.keys.length; i < len; i++) {
+          const n = cloneNode(await ops.getNode(siblingNode.keys[i]));
+          n.parent = siblingNode.id;
+          await ops.updateNode(n);
+        }
       }
-    );
-  }
-  /**
-   * Releases a read lock by its lock ID.
-   * @param lockId - The unique identifier for the lock to release.
-   */
-  readUnlock(lockId) {
-    this._free(this.readings, lockId);
-  }
-  /**
-   * Releases a write lock by its lock ID.
-   * @param lockId - The unique identifier for the lock to release.
-   */
-  writeUnlock(lockId) {
-    this._free(this.writings, lockId);
-  }
-};
+      await ops.deleteNode(node);
+      await ops.updateNode(siblingNode);
+      await deleteEntryAsync(ops, ctx, await ops.getNode(node.parent), node.id, comparator);
+    } else {
+      if (isPredecessor) {
+        let pointerPm, pointerKm;
+        if (!node.leaf) {
+          pointerPm = siblingNode.keys.splice(-1)[0];
+          pointerKm = siblingNode.values.splice(-1)[0];
+          node.keys = [pointerPm, ...node.keys];
+          node.values = [guess, ...node.values];
+          parentNode = cloneNode(await ops.getNode(node.parent));
+          const ni = parentNode.keys.indexOf(node.id);
+          if (ni > 0) {
+            parentNode.values[ni - 1] = pointerKm;
+            await ops.updateNode(parentNode);
+          }
+        } else {
+          pointerPm = siblingNode.keys.splice(-1)[0];
+          pointerKm = siblingNode.values.splice(-1)[0];
+          node.keys = [pointerPm, ...node.keys];
+          node.values = [pointerKm, ...node.values];
+          parentNode = cloneNode(await ops.getNode(node.parent));
+          const ni = parentNode.keys.indexOf(node.id);
+          if (ni > 0) {
+            parentNode.values[ni - 1] = pointerKm;
+            await ops.updateNode(parentNode);
+          }
+        }
+        await ops.updateNode(node);
+        await ops.updateNode(siblingNode);
+      } else {
+        let pointerP0, pointerK0;
+        if (!node.leaf) {
+          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 = cloneNode(await ops.getNode(node.parent));
+          const pi = parentNode.keys.indexOf(siblingNode.id);
+          if (pi > 0) {
+            parentNode.values[pi - 1] = pointerK0;
+            await ops.updateNode(parentNode);
+          }
+        } else {
+          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 = cloneNode(await ops.getNode(node.parent));
+          const pi = parentNode.keys.indexOf(siblingNode.id);
+          if (pi > 0) {
+            parentNode.values[pi - 1] = siblingNode.values[0];
+            await ops.updateNode(parentNode);
+          }
+        }
+        await ops.updateNode(node);
+        await ops.updateNode(siblingNode);
+      }
+      if (!siblingNode.leaf) {
+        for (let i = 0, len = siblingNode.keys.length; i < len; i++) {
+          const n = cloneNode(await ops.getNode(siblingNode.keys[i]));
+          n.parent = siblingNode.id;
+          await ops.updateNode(n);
+        }
+      }
+      if (!node.leaf) {
+        for (let i = 0, len = node.keys.length; i < len; i++) {
+          const n = cloneNode(await ops.getNode(node.keys[i]));
+          n.parent = node.id;
+          await ops.updateNode(n);
+        }
+      }
+      if (!parentNode.leaf) {
+        for (let i = 0, len = parentNode.keys.length; i < len; i++) {
+          const n = cloneNode(await ops.getNode(parentNode.keys[i]));
+          n.parent = parentNode.id;
+          await ops.updateNode(n);
+        }
+      }
+    }
+  } else {
+    await ops.updateNode(cloneNode(node));
+  }
+  return node;
+}
+async function deleteOpAsync(ops, ctx, key, comparator, value) {
+  if (value === void 0) {
+    value = await getOpAsync(ops, ctx.rootId, key);
+  }
+  if (value === void 0) return;
+  let node = await findLowerBoundLeafAsync(ops, ctx.rootId, value, comparator);
+  let found = false;
+  while (true) {
+    let i = node.values.length;
+    while (i--) {
+      if (comparator.isSame(value, node.values[i])) {
+        const keyIndex = node.keys[i].indexOf(key);
+        if (keyIndex !== -1) {
+          node = cloneNode(node);
+          node.keys[i].splice(keyIndex, 1);
+          if (node.keys[i].length === 0) {
+            node.keys.splice(i, 1);
+            node.values.splice(i, 1);
+          }
+          await ops.updateNode(node);
+          node = await deleteEntryAsync(ops, ctx, node, key, comparator);
+          found = true;
+          break;
+        }
+      }
+    }
+    if (found) break;
+    if (node.next) {
+      node = await ops.getNode(node.next);
+      continue;
+    }
+    break;
+  }
+}
+async function batchInsertOpAsync(ops, ctx, entries, comparator) {
+  if (entries.length === 0) return;
+  const sorted = [...entries].sort((a, b) => comparator.asc(a[1], b[1]));
+  let currentLeaf = null;
+  let modified = false;
+  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 && (comparator.isLower(value, cachedLeafMaxValue) || comparator.isSame(value, cachedLeafMaxValue))) {
+      targetLeaf = currentLeaf;
+    } else {
+      targetLeaf = await locateLeafAsync(ops, ctx.rootId, value, comparator);
+    }
+    if (currentLeaf !== null && currentLeaf.id === targetLeaf.id) {
+    } else {
+      if (currentLeaf !== null && modified) await ops.updateNode(currentLeaf);
+      currentLeaf = cloneNode(targetLeaf);
+      modified = false;
+    }
+    cachedLeafId = currentLeaf.id;
+    const changed = insertValueIntoLeaf(currentLeaf, key, value, comparator);
+    modified = modified || changed;
+    cachedLeafMaxValue = currentLeaf.values[currentLeaf.values.length - 1];
+    if (currentLeaf.values.length === ctx.order) {
+      await ops.updateNode(currentLeaf);
+      let after = await ops.createNode(true, [], [], currentLeaf.parent, null, null);
+      const mid = Math.ceil(ctx.order / 2) - 1;
+      after = cloneNode(after);
+      after.values = currentLeaf.values.slice(mid + 1);
+      after.keys = currentLeaf.keys.slice(mid + 1);
+      currentLeaf.values = currentLeaf.values.slice(0, mid + 1);
+      currentLeaf.keys = currentLeaf.keys.slice(0, mid + 1);
+      await ops.updateNode(currentLeaf);
+      await ops.updateNode(after);
+      await insertInParentAsync(ops, ctx, currentLeaf, after.values[0], after);
+      currentLeaf = null;
+      cachedLeafId = null;
+      cachedLeafMaxValue = null;
+      modified = false;
+    }
+  }
+  if (currentLeaf !== null && modified) await ops.updateNode(currentLeaf);
+}
+async function bulkLoadOpAsync(ops, ctx, entries, comparator) {
+  if (entries.length === 0) return;
+  const root = await ops.getNode(ctx.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) => 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 && comparator.isSame(last.value, value)) {
+      if (!last.keys.includes(key)) last.keys.push(key);
+    } else {
+      grouped.push({ keys: [key], value });
+    }
+  }
+  await ops.deleteNode(root);
+  const maxLeafSize = ctx.order - 1;
+  const leaves = [];
+  for (let i = 0, len = grouped.length; i < len; i += maxLeafSize) {
+    const chunk = grouped.slice(i, i + maxLeafSize);
+    const leaf = await ops.createNode(true, chunk.map((g) => g.keys), chunk.map((g) => g.value), 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 ops.updateNode(leaves[i]);
+  }
+  let currentLevel = leaves;
+  while (currentLevel.length > 1) {
+    const nextLevel = [];
+    for (let i = 0, len = currentLevel.length; i < len; i += ctx.order) {
+      const children = currentLevel.slice(i, i + ctx.order);
+      const separators = [];
+      for (let j = 1, cLen = children.length; j < cLen; j++) separators.push(children[j].values[0]);
+      const internalNode = await ops.createNode(false, children.map((c) => c.id), separators, null, null, null);
+      for (let j = 0, cLen = children.length; j < cLen; j++) {
+        children[j].parent = internalNode.id;
+        await ops.updateNode(children[j]);
+      }
+      nextLevel.push(internalNode);
+    }
+    currentLevel = nextLevel;
+  }
+  const newRoot = currentLevel[0];
+  await ops.writeHead({ root: newRoot.id, order: ctx.order, data: ctx.headData() });
+  ctx.rootId = newRoot.id;
+}
+async function existsOpAsync(ops, rootId, key, value, comparator) {
+  const node = await locateLeafAsync(ops, rootId, value, comparator);
+  const { index, found } = binarySearchValues(node.values, value, comparator);
+  if (found && node.keys[index].includes(key)) return true;
+  return false;
+}
+async function getOpAsync(ops, rootId, key) {
+  let node = await leftestNodeAsync(ops, rootId);
+  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++) {
+        if (keys[j] === key) return node.values[i];
+      }
+    }
+    if (!node.next) break;
+    node = await ops.getNode(node.next);
+  }
+  return void 0;
+}
+async function* whereStreamOpAsync(ops, rootId, condition, comparator, verifierMap, searchConfigs, ensureValues, options) {
+  const { filterValues, limit, order = "asc" } = options ?? {};
+  const conditionKeys = Object.keys(condition);
+  if (conditionKeys.length === 0) return;
+  const resolved = resolveStartEndConfigs(condition, order, comparator, ensureValues);
+  const direction = resolved.direction;
+  let startNode;
+  if (resolved.startKey) {
+    const startConfig = searchConfigs[resolved.startKey][order];
+    startNode = await startConfig.start(rootId, ops, resolved.startValues);
+  } else {
+    startNode = order === "asc" ? await leftestNodeAsync(ops, rootId) : await rightestNodeAsync(ops, rootId);
+  }
+  let endNode = null;
+  if (resolved.endKey) {
+    const endConfig = searchConfigs[resolved.endKey][order];
+    endNode = await endConfig.end(rootId, ops, resolved.endValues);
+  }
+  if (!startNode) return;
+  const generator = getPairsGeneratorAsync(ops, startNode, endNode, direction);
+  let count = 0;
+  const intersection = filterValues && filterValues.size > 0 ? filterValues : null;
+  for await (const pair of generator) {
+    const [k, v] = pair;
+    if (intersection && !intersection.has(k)) continue;
+    if (verify(v, condition, verifierMap)) {
+      yield pair;
+      count++;
+      if (limit !== void 0 && count >= limit) break;
+    }
+  }
+}
+async function* keysStreamOpAsync(ops, rootId, condition, comparator, verifierMap, searchConfigs, ensureValues, options) {
+  const { filterValues, limit } = options ?? {};
+  const stream = whereStreamOpAsync(ops, rootId, condition, comparator, verifierMap, searchConfigs, ensureValues, options);
+  const intersection = filterValues && filterValues.size > 0 ? filterValues : null;
+  let count = 0;
+  for await (const [key] of stream) {
+    if (intersection && !intersection.has(key)) continue;
+    yield key;
+    count++;
+    if (limit !== void 0 && count >= limit) break;
+  }
+}
+async function initOpAsync(ops, ctx, strategyOrder, strategyHead, setStrategyHead) {
+  const head = await ops.readHead();
+  if (head === null) {
+    ctx.order = strategyOrder;
+    const root = await ops.createNode(true, [], []);
+    await ops.writeHead({ root: root.id, order: ctx.order, data: strategyHead.data });
+    ctx.rootId = root.id;
+  } else {
+    const { root, order } = head;
+    setStrategyHead(head);
+    ctx.order = order;
+    ctx.rootId = root;
+  }
+  if (ctx.order < 3) {
+    throw new Error(`The 'order' parameter must be greater than 2. but got a '${ctx.order}'.`);
+  }
+}
 
 // src/transaction/BPTreeAsyncTransaction.ts
 var BPTreeAsyncTransaction = class extends BPTreeTransaction {
   lock;
+  _ops;
+  _ctx;
+  _verifierMapCached;
+  _searchConfigsCached;
   constructor(rootTx, mvccRoot, mvcc, strategy, comparator, option) {
     super(
       rootTx,
@@ -3266,6 +4568,64 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
       option
     );
     this.lock = new Ryoiki2();
+    this._initAlgoContext();
+  }
+  _initAlgoContext() {
+    const mvcc = this.mvcc;
+    const strategy = this.strategy;
+    const self = this;
+    this._ops = {
+      async getNode(id) {
+        return await mvcc.read(id);
+      },
+      async createNode(leaf, keys, values, parent = null, next = null, prev = null) {
+        const id = await strategy.id(leaf);
+        const node = { id, keys, values, leaf, parent, next, prev };
+        await mvcc.create(id, node);
+        return node;
+      },
+      async updateNode(node) {
+        if (mvcc.isDeleted(node.id)) {
+          return;
+        }
+        await mvcc.write(node.id, node);
+      },
+      async deleteNode(node) {
+        if (mvcc.isDeleted(node.id)) {
+          return;
+        }
+        await mvcc.delete(node.id);
+      },
+      async readHead() {
+        return await mvcc.read("__HEAD__");
+      },
+      async writeHead(head) {
+        if (!await mvcc.exists("__HEAD__")) {
+          await mvcc.create("__HEAD__", head);
+        } else {
+          await mvcc.write("__HEAD__", head);
+        }
+        self.rootId = head.root;
+      }
+    };
+    this._ctx = {
+      get rootId() {
+        return self.rootId;
+      },
+      set rootId(v) {
+        self.rootId = v;
+      },
+      get order() {
+        return self.order;
+      },
+      set order(v) {
+        self.order = v;
+      },
+      headData: () => this.strategy.head.data
+    };
+    const ensureValues = (v) => this.ensureValues(v);
+    this._verifierMapCached = createVerifierMap(this.comparator, this._cachedRegexp, ensureValues);
+    this._searchConfigsCached = createSearchConfigsAsync(this.comparator, ensureValues);
   }
   async writeLock(id, fn) {
     let lockId;
@@ -3276,256 +4636,54 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
       this.lock.writeUnlock(lockId);
     });
   }
+  // ─── Legacy protected methods (delegating to ops) ────────────────
   async getNode(id) {
-    return await this.mvcc.read(id);
+    return this._ops.getNode(id);
   }
-  /**
-   * Create a new node with a unique ID.
-   */
   async _createNode(leaf, keys, values, parent = null, next = null, prev = null) {
-    const id = await this.strategy.id(leaf);
-    const node = {
-      id,
-      keys,
-      values,
-      leaf,
-      parent,
-      next,
-      prev
-    };
-    await this.mvcc.create(id, node);
-    return node;
+    return this._ops.createNode(leaf, keys, values, parent, next, prev);
   }
   async _updateNode(node) {
-    if (this.mvcc.isDeleted(node.id)) {
-      return;
-    }
-    await this.mvcc.write(node.id, node);
+    await this._ops.updateNode(node);
   }
   async _deleteNode(node) {
-    if (this.mvcc.isDeleted(node.id)) {
-      return;
-    }
-    await this.mvcc.delete(node.id);
+    await this._ops.deleteNode(node);
   }
   async _readHead() {
-    return await this.mvcc.read("__HEAD__");
+    return this._ops.readHead();
   }
   async _writeHead(head) {
-    if (!await this.mvcc.exists("__HEAD__")) {
-      await this.mvcc.create("__HEAD__", head);
-    } else {
-      await this.mvcc.write("__HEAD__", head);
-    }
-    this.rootId = head.root;
+    await this._ops.writeHead(head);
   }
+  // ─── Tree traversal (delegating to algorithm) ────────────────────
   async _insertAtLeaf(node, key, value) {
-    let leaf = node;
-    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)) {
-          const keys = leaf.keys[i];
-          if (keys.includes(key)) {
-            break;
-          }
-          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);
-          return leaf;
-        }
-      }
-    } else {
-      leaf = this._cloneNode(leaf);
-      leaf.values = [value];
-      leaf.keys = [[key]];
-      await this._updateNode(leaf);
-      return leaf;
-    }
-    return leaf;
+    return insertAtLeafAsync(this._ops, node, key, value, this.comparator);
   }
   async _insertInParent(node, value, newSiblingNode) {
-    if (this.rootId === node.id) {
-      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;
-      newSiblingNode.parent = root.id;
-      if (newSiblingNode.leaf) {
-        node.next = newSiblingNode.id;
-        newSiblingNode.prev = node.id;
-      }
-      await this._writeHead({
-        root: root.id,
-        order: this.order,
-        data: this.strategy.head.data
-      });
-      await this._updateNode(node);
-      await this._updateNode(newSiblingNode);
-      return;
-    }
-    const parentNode = this._cloneNode(await this.getNode(node.parent));
-    const nodeIndex = parentNode.keys.indexOf(node.id);
-    if (nodeIndex === -1) {
-      throw new Error(`Node ${node.id} not found in parent ${parentNode.id}`);
-    }
-    parentNode.values.splice(nodeIndex, 0, value);
-    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;
-      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 = newSiblingNode.id;
-        await this._updateNode(oldNext);
-      }
-    }
-    await this._updateNode(parentNode);
-    await this._updateNode(newSiblingNode);
-    if (parentNode.keys.length > this.order) {
-      const newSiblingNodeRecursive = await this._createNode(false, [], []);
-      newSiblingNodeRecursive.parent = parentNode.parent;
-      const mid = Math.ceil(this.order / 2) - 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);
-      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);
-      }
-      await this._updateNode(parentNode);
-      await this._insertInParent(parentNode, midValue, newSiblingNodeRecursive);
-    }
+    await insertInParentAsync(this._ops, this._ctx, node, value, newSiblingNode);
   }
   async locateLeaf(value) {
-    let node = await this.getNode(this.rootId);
-    while (!node.leaf) {
-      const { index } = this._binarySearchValues(node.values, value, false, true);
-      node = await this.getNode(node.keys[index]);
-    }
-    return node;
+    return locateLeafAsync(this._ops, this._ctx.rootId, value, this.comparator);
   }
   async findLowerBoundLeaf(value) {
-    let node = await this.getNode(this.rootId);
-    while (!node.leaf) {
-      const { index } = this._binarySearchValues(node.values, value, true, false);
-      node = await this.getNode(node.keys[index]);
-    }
-    return node;
+    return findLowerBoundLeafAsync(this._ops, this._ctx.rootId, value, this.comparator);
   }
   async findUpperBoundLeaf(value) {
-    let node = await this.getNode(this.rootId);
-    while (!node.leaf) {
-      const { index } = this._binarySearchValues(node.values, value, true, true);
-      node = await this.getNode(node.keys[index]);
-    }
-    return node;
+    return findUpperBoundLeafAsync(this._ops, this._ctx.rootId, value, this.comparator);
   }
   async findOuterBoundaryLeaf(value, direction) {
-    const insertableNode = direction === -1 ? await this.findLowerBoundLeaf(value) : await this.findUpperBoundLeaf(value);
-    let key;
-    switch (direction) {
-      case -1:
-        key = "prev";
-        break;
-      case 1:
-        key = "next";
-        break;
-      default:
-        throw new Error(`Direction must be -1 or 1. but got a ${direction}`);
-    }
-    const guessNode = insertableNode[key];
-    if (!guessNode) {
-      return null;
-    }
-    return await this.getNode(guessNode);
+    return findOuterBoundaryLeafAsync(this._ops, this._ctx.rootId, value, direction, this.comparator);
   }
   async leftestNode() {
-    let node = await this.getNode(this.rootId);
-    if (node === null) {
-      debugger;
-    }
-    while (!node.leaf) {
-      const keys = node.keys;
-      node = await this.getNode(keys[0]);
-    }
-    return node;
+    return leftestNodeAsync(this._ops, this._ctx.rootId);
   }
   async rightestNode() {
-    let node = await this.getNode(this.rootId);
-    while (!node.leaf) {
-      const keys = node.keys;
-      node = await this.getNode(keys[keys.length - 1]);
-    }
-    return node;
+    return rightestNodeAsync(this._ops, this._ctx.rootId);
   }
   async *getPairsGenerator(startNode, endNode, direction) {
-    let node = startNode;
-    let nextNodePromise = null;
-    while (true) {
-      if (endNode && node.id === endNode.id) {
-        break;
-      }
-      if (direction === 1) {
-        if (node.next) {
-          nextNodePromise = this.getNode(node.next);
-        }
-      } else {
-        if (node.prev) {
-          nextNodePromise = this.getNode(node.prev);
-        }
-      }
-      const len = node.values.length;
-      if (direction === 1) {
-        for (let i = 0; i < len; i++) {
-          const nValue = node.values[i];
-          const keys = node.keys[i];
-          for (let j = 0, len2 = keys.length; j < len2; j++) {
-            yield [keys[j], nValue];
-          }
-        }
-      } else {
-        let i = len;
-        while (i--) {
-          const nValue = node.values[i];
-          const keys = node.keys[i];
-          let j = keys.length;
-          while (j--) {
-            yield [keys[j], nValue];
-          }
-        }
-      }
-      if (nextNodePromise) {
-        node = await nextNodePromise;
-        nextNodePromise = null;
-      } else {
-        break;
-      }
-    }
+    yield* getPairsGeneratorAsync(this._ops, startNode, endNode, direction);
   }
+  // ─── Lifecycle ───────────────────────────────────────────────────
   async init() {
     if (this.rootTx !== this) {
       throw new Error("Cannot call init on a nested transaction");
@@ -3542,24 +4700,15 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
     this.isInitialized = true;
     try {
       this._clearCache();
-      const head = await this._readHead();
-      if (head === null) {
-        this.order = this.strategy.order;
-        const root = await this._createNode(true, [], []);
-        await this._writeHead({
-          root: root.id,
-          order: this.order,
-          data: this.strategy.head.data
-        });
-      } else {
-        const { root, order } = head;
-        this.strategy.head = head;
-        this.order = order;
-        this.rootId = root;
-      }
-      if (this.order < 3) {
-        throw new Error(`The 'order' parameter must be greater than 2. but got a '${this.order}'.`);
-      }
+      await initOpAsync(
+        this._ops,
+        this._ctx,
+        this.strategy.order,
+        this.strategy.head,
+        (head) => {
+          this.strategy.head = head;
+        }
+      );
     } catch (e) {
       this.isInitialized = false;
       throw e;
@@ -3575,88 +4724,36 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
     this._resetForReload();
     await this._initInternal();
   }
+  // ─── Query (delegating to algorithm) ─────────────────────────────
   async exists(key, value) {
-    const node = await this.locateLeaf(value);
-    const { index, found } = this._binarySearchValues(node.values, value);
-    if (found) {
-      const keys = node.keys[index];
-      if (keys.includes(key)) {
-        return true;
-      }
-    }
-    return false;
+    return existsOpAsync(this._ops, this._ctx.rootId, key, value, this.comparator);
   }
   async get(key) {
-    let node = await this.leftestNode();
-    while (true) {
-      for (let i = 0, len = node.values.length; i < len; i++) {
-        const keys = node.keys[i];
-        for (let j = 0, len2 = keys.length; j < len2; j++) {
-          if (keys[j] === key) {
-            return node.values[i];
-          }
-        }
-      }
-      if (!node.next) break;
-      node = await this.getNode(node.next);
-    }
-    return void 0;
+    return getOpAsync(this._ops, this._ctx.rootId, key);
   }
   async *keysStream(condition, options) {
-    const { filterValues, limit, order = "asc" } = options ?? {};
-    const stream = this.whereStream(condition, options);
-    const intersection = filterValues && filterValues.size > 0 ? filterValues : null;
-    let count = 0;
-    for await (const [key] of stream) {
-      if (intersection && !intersection.has(key)) {
-        continue;
-      }
-      yield key;
-      count++;
-      if (limit !== void 0 && count >= limit) {
-        break;
-      }
-    }
+    yield* keysStreamOpAsync(
+      this._ops,
+      this._ctx.rootId,
+      condition,
+      this.comparator,
+      this._verifierMapCached,
+      this._searchConfigsCached,
+      this.ensureValues.bind(this),
+      options
+    );
   }
   async *whereStream(condition, options) {
-    const { filterValues, limit, order = "asc" } = options ?? {};
-    const conditionKeys = Object.keys(condition);
-    if (conditionKeys.length === 0) return;
-    const resolved = this.resolveStartEndConfigs(condition, order);
-    const direction = resolved.direction;
-    let startNode;
-    if (resolved.startKey) {
-      const startConfig = this.searchConfigs[resolved.startKey][order];
-      startNode = await startConfig.start(this, resolved.startValues);
-    } else {
-      startNode = order === "asc" ? await this.leftestNode() : await this.rightestNode();
-    }
-    let endNode = null;
-    if (resolved.endKey) {
-      const endConfig = this.searchConfigs[resolved.endKey][order];
-      endNode = await endConfig.end(this, resolved.endValues);
-    }
-    if (!startNode) return;
-    const generator = this.getPairsGenerator(
-      startNode,
-      endNode,
-      direction
+    yield* whereStreamOpAsync(
+      this._ops,
+      this._ctx.rootId,
+      condition,
+      this.comparator,
+      this._verifierMapCached,
+      this._searchConfigsCached,
+      this.ensureValues.bind(this),
+      options
     );
-    let count = 0;
-    const intersection = filterValues && filterValues.size > 0 ? filterValues : null;
-    for await (const pair of generator) {
-      const [k, v] = pair;
-      if (intersection && !intersection.has(k)) {
-        continue;
-      }
-      if (this.verify(v, condition)) {
-        yield pair;
-        count++;
-        if (limit !== void 0 && count >= limit) {
-          break;
-        }
-      }
-    }
   }
   async keys(condition, options) {
     const set = /* @__PURE__ */ new Set();
@@ -3668,416 +4765,37 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
   async where(condition, options) {
     const map = /* @__PURE__ */ new Map();
     for await (const [key, value] of this.whereStream(condition, options)) {
-      map.set(key, value);
-    }
-    return map;
-  }
-  async insert(key, value) {
-    return this.writeLock(0, async () => {
-      let before = await this.locateLeaf(value);
-      before = await this._insertAtLeaf(before, key, value);
-      if (before.values.length === this.order) {
-        let after = await this._createNode(
-          true,
-          [],
-          [],
-          before.parent,
-          null,
-          null
-        );
-        const mid = Math.ceil(this.order / 2) - 1;
-        after = this._cloneNode(after);
-        after.values = before.values.slice(mid + 1);
-        after.keys = before.keys.slice(mid + 1);
-        before.values = before.values.slice(0, mid + 1);
-        before.keys = before.keys.slice(0, mid + 1);
-        await this._updateNode(before);
-        await this._updateNode(after);
-        await this._insertInParent(before, after.values[0], after);
-      }
-    });
-  }
-  async batchInsert(entries) {
-    if (entries.length === 0) return;
-    return this.writeLock(0, async () => {
-      const sorted = [...entries].sort((a, b) => this.comparator.asc(a[1], b[1]));
-      let currentLeaf = null;
-      let modified = false;
-      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) {
-            await this._updateNode(currentLeaf);
-          }
-          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(
-            true,
-            [],
-            [],
-            currentLeaf.parent,
-            null,
-            null
-          );
-          const mid = Math.ceil(this.order / 2) - 1;
-          after = this._cloneNode(after);
-          after.values = currentLeaf.values.slice(mid + 1);
-          after.keys = currentLeaf.keys.slice(mid + 1);
-          currentLeaf.values = currentLeaf.values.slice(0, mid + 1);
-          currentLeaf.keys = currentLeaf.keys.slice(0, mid + 1);
-          await this._updateNode(currentLeaf);
-          await this._updateNode(after);
-          await this._insertInParent(currentLeaf, after.values[0], after);
-          currentLeaf = null;
-          cachedLeafId = null;
-          cachedLeafMaxValue = null;
-          modified = false;
-        }
-      }
-      if (currentLeaf !== null && modified) {
-        await this._updateNode(currentLeaf);
-      }
-    });
-  }
-  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;
-      for (let i = 0, len = node.keys.length; i < len; i++) {
-        if (node.keys[i] === key) {
-          keyIndex = i;
-          break;
-        }
-      }
-      if (keyIndex !== -1) {
-        node = this._cloneNode(node);
-        node.keys.splice(keyIndex, 1);
-        const valueIndex = keyIndex > 0 ? keyIndex - 1 : 0;
-        node.values.splice(valueIndex, 1);
-        await this._updateNode(node);
-      }
-    }
-    if (this.rootId === node.id && node.keys.length === 1 && !node.leaf) {
-      const keys = node.keys;
-      this._deleteNode(node);
-      const newRoot = this._cloneNode(await this.getNode(keys[0]));
-      newRoot.parent = null;
-      await this._updateNode(newRoot);
-      await this._writeHead({
-        root: newRoot.id,
-        order: this.order,
-        data: this.strategy.head.data
-      });
-      return node;
-    } else if (this.rootId === node.id) {
-      await this._writeHead({
-        root: node.id,
-        order: this.order,
-        data: this.strategy.head.data
-      });
-      return node;
-    } else if (node.keys.length < Math.ceil(this.order / 2) && !node.leaf || node.values.length < Math.ceil((this.order - 1) / 2) && node.leaf) {
-      if (node.parent === null) {
-        return node;
-      }
-      let isPredecessor = false;
-      let parentNode = await this.getNode(node.parent);
-      let prevNode = null;
-      let nextNode = null;
-      let prevValue = null;
-      let postValue = null;
-      for (let i = 0, len = parentNode.keys.length; i < len; i++) {
-        const nKey = parentNode.keys[i];
-        if (nKey === node.id) {
-          if (i > 0) {
-            prevNode = await this.getNode(parentNode.keys[i - 1]);
-            prevValue = parentNode.values[i - 1];
-          }
-          if (i < parentNode.keys.length - 1) {
-            nextNode = await this.getNode(parentNode.keys[i + 1]);
-            postValue = parentNode.values[i];
-          }
-        }
-      }
-      let siblingNode;
-      let guess;
-      if (prevNode === null) {
-        siblingNode = nextNode;
-        guess = postValue;
-      } else if (nextNode === null) {
-        isPredecessor = true;
-        siblingNode = prevNode;
-        guess = prevValue;
-      } else {
-        if (node.values.length + nextNode.values.length < this.order) {
-          siblingNode = nextNode;
-          guess = postValue;
-        } else {
-          isPredecessor = true;
-          siblingNode = prevNode;
-          guess = prevValue;
-        }
-      }
-      if (!siblingNode) {
-        return node;
-      }
-      node = this._cloneNode(node);
-      siblingNode = this._cloneNode(siblingNode);
-      if (node.values.length + siblingNode.values.length < this.order) {
-        if (!isPredecessor) {
-          const pTemp = siblingNode;
-          siblingNode = node;
-          node = pTemp;
-        }
-        siblingNode.keys.push(...node.keys);
-        if (!node.leaf) {
-          siblingNode.values.push(guess);
-        } else {
-          siblingNode.next = node.next;
-          if (siblingNode.next) {
-            const n = this._cloneNode(await this.getNode(siblingNode.next));
-            n.prev = siblingNode.id;
-            await this._updateNode(n);
-          }
-        }
-        siblingNode.values.push(...node.values);
-        if (!siblingNode.leaf) {
-          const keys = siblingNode.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);
-          }
-        }
-        this._deleteNode(node);
-        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 = 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));
-            const nodeIndex = parentNode.keys.indexOf(node.id);
-            if (nodeIndex > 0) {
-              parentNode.values[nodeIndex - 1] = pointerKm;
-              await this._updateNode(parentNode);
-            }
-          } else {
-            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));
-            const nodeIndex = parentNode.keys.indexOf(node.id);
-            if (nodeIndex > 0) {
-              parentNode.values[nodeIndex - 1] = pointerKm;
-              await this._updateNode(parentNode);
-            }
-          }
-          await this._updateNode(node);
-          await this._updateNode(siblingNode);
-        } else {
-          let pointerP0;
-          let pointerK0;
-          if (!node.leaf) {
-            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(siblingNode.id);
-            if (pointerIndex > 0) {
-              parentNode.values[pointerIndex - 1] = pointerK0;
-              await this._updateNode(parentNode);
-            }
-          } else {
-            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(siblingNode.id);
-            if (pointerIndex > 0) {
-              parentNode.values[pointerIndex - 1] = siblingNode.values[0];
-              await this._updateNode(parentNode);
-            }
-          }
-          await this._updateNode(node);
-          await this._updateNode(siblingNode);
-        }
-        if (!siblingNode.leaf) {
-          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 (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 (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);
-          }
-        }
-      }
-    } else {
-      await this._updateNode(this._cloneNode(node));
+      map.set(key, value);
     }
-    return node;
+    return map;
+  }
+  // ─── Mutation (delegating to algorithm) ──────────────────────────
+  async insert(key, value) {
+    return this.writeLock(0, async () => {
+      await insertOpAsync(this._ops, this._ctx, key, value, this.comparator);
+    });
+  }
+  async batchInsert(entries) {
+    if (entries.length === 0) return;
+    return this.writeLock(0, async () => {
+      await batchInsertOpAsync(this._ops, this._ctx, entries, this.comparator);
+    });
+  }
+  async bulkLoad(entries) {
+    if (entries.length === 0) return;
+    return this.writeLock(0, async () => {
+      await bulkLoadOpAsync(this._ops, this._ctx, entries, this.comparator);
+    });
+  }
+  async _deleteEntry(node, key) {
+    return deleteEntryAsync(this._ops, this._ctx, node, key, this.comparator);
   }
   async delete(key, value) {
     return this.writeLock(0, async () => {
-      if (value === void 0) {
-        value = await this.get(key);
-      }
-      if (value === void 0) {
-        return;
-      }
-      let node = await this.findLowerBoundLeaf(value);
-      let found = false;
-      while (true) {
-        let i = node.values.length;
-        while (i--) {
-          const nValue = node.values[i];
-          if (this.comparator.isSame(value, nValue)) {
-            const keys = node.keys[i];
-            const keyIndex = keys.indexOf(key);
-            if (keyIndex !== -1) {
-              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);
-              }
-              await this._updateNode(node);
-              node = await this._deleteEntry(node, key);
-              found = true;
-              break;
-            }
-          }
-        }
-        if (found) break;
-        if (node.next) {
-          node = await this.getNode(node.next);
-          continue;
-        }
-        break;
-      }
+      await deleteOpAsync(this._ops, this._ctx, key, this.comparator, value);
     });
   }
+  // ─── Head Data ───────────────────────────────────────────────────
   async getHeadData() {
     const head = await this._readHead();
     if (head === null) {
@@ -4096,6 +4814,7 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
       data
     });
   }
+  // ─── Transaction ─────────────────────────────────────────────────
   async commit(label) {
     let result = await this.mvcc.commit(label);
     if (result.success) {
@@ -4227,6 +4946,467 @@ var BPTreeAsync = class extends BPTreeAsyncTransaction {
   }
 };
 
+// src/BPTreePureSync.ts
+var BPTreePureSync = class {
+  strategy;
+  comparator;
+  option;
+  _cachedRegexp = /* @__PURE__ */ new Map();
+  _ctx;
+  _ops;
+  _verifierMap;
+  _searchConfigs;
+  constructor(strategy, comparator, option) {
+    this.strategy = strategy;
+    this.comparator = comparator;
+    this.option = option ?? {};
+    const ensureValues = (v) => Array.isArray(v) ? v : [v];
+    this._verifierMap = createVerifierMap(comparator, this._cachedRegexp, ensureValues);
+    this._searchConfigs = createSearchConfigs(comparator, ensureValues);
+  }
+  _ensureValues(v) {
+    return Array.isArray(v) ? v : [v];
+  }
+  _createOps() {
+    const strategy = this.strategy;
+    return {
+      getNode(id) {
+        return strategy.read(id);
+      },
+      createNode(leaf, keys, values, parent = null, next = null, prev = null) {
+        const id = strategy.id(leaf);
+        const node = { id, keys, values, leaf, parent, next, prev };
+        return node;
+      },
+      updateNode() {
+      },
+      deleteNode() {
+      },
+      readHead() {
+        return strategy.readHead();
+      },
+      writeHead() {
+      }
+    };
+  }
+  _createBufferedOps() {
+    const strategy = this.strategy;
+    const writeBuffer = /* @__PURE__ */ new Map();
+    const deleteBuffer = /* @__PURE__ */ new Set();
+    let headBuffer = null;
+    const ops = {
+      getNode(id) {
+        const buffered = writeBuffer.get(id);
+        if (buffered) return buffered;
+        return strategy.read(id);
+      },
+      createNode(leaf, keys, values, parent = null, next = null, prev = null) {
+        const id = strategy.id(leaf);
+        const node = { id, keys, values, leaf, parent, next, prev };
+        writeBuffer.set(id, node);
+        return node;
+      },
+      updateNode(node) {
+        writeBuffer.set(node.id, node);
+      },
+      deleteNode(node) {
+        deleteBuffer.add(node.id);
+        writeBuffer.delete(node.id);
+      },
+      readHead() {
+        if (headBuffer) return headBuffer;
+        return strategy.readHead();
+      },
+      writeHead(head) {
+        headBuffer = head;
+      }
+    };
+    function flush() {
+      for (const id of deleteBuffer) {
+        strategy.delete(id);
+      }
+      for (const [id, node] of writeBuffer) {
+        strategy.write(id, node);
+      }
+      if (headBuffer) {
+        strategy.writeHead(headBuffer);
+      }
+    }
+    return { ops, flush };
+  }
+  init() {
+    const { ops, flush } = this._createBufferedOps();
+    this._ctx = {
+      rootId: "",
+      order: this.strategy.order,
+      headData: () => this.strategy.head.data
+    };
+    initOp(
+      ops,
+      this._ctx,
+      this.strategy.order,
+      this.strategy.head,
+      (head) => {
+        this.strategy.head = head;
+      }
+    );
+    flush();
+    this._ops = this._createOps();
+  }
+  /**
+   * Returns the ID of the root node.
+   */
+  getRootId() {
+    return this._ctx.rootId;
+  }
+  /**
+   * Returns the order of the B+Tree.
+   */
+  getOrder() {
+    return this._ctx.order;
+  }
+  /**
+   * Verified if the value satisfies the condition.
+   */
+  verify(nodeValue, condition) {
+    for (const key in condition) {
+      const verifyFn = this._verifierMap[key];
+      const condValue = condition[key];
+      if (!verifyFn(nodeValue, condValue)) {
+        return false;
+      }
+    }
+    return true;
+  }
+  // ─── Query ───────────────────────────────────────────────────────
+  get(key) {
+    return getOp(this._ops, this._ctx.rootId, key);
+  }
+  exists(key, value) {
+    return existsOp(this._ops, this._ctx.rootId, key, value, this.comparator);
+  }
+  *keysStream(condition, options) {
+    yield* keysStreamOp(
+      this._ops,
+      this._ctx.rootId,
+      condition,
+      this.comparator,
+      this._verifierMap,
+      this._searchConfigs,
+      this._ensureValues,
+      options
+    );
+  }
+  *whereStream(condition, options) {
+    yield* whereStreamOp(
+      this._ops,
+      this._ctx.rootId,
+      condition,
+      this.comparator,
+      this._verifierMap,
+      this._searchConfigs,
+      this._ensureValues,
+      options
+    );
+  }
+  keys(condition, options) {
+    const set = /* @__PURE__ */ new Set();
+    for (const key of this.keysStream(condition, options)) {
+      set.add(key);
+    }
+    return set;
+  }
+  where(condition, options) {
+    const map = /* @__PURE__ */ new Map();
+    for (const [key, value] of this.whereStream(condition, options)) {
+      map.set(key, value);
+    }
+    return map;
+  }
+  // ─── Mutation ────────────────────────────────────────────────────
+  insert(key, value) {
+    const { ops, flush } = this._createBufferedOps();
+    insertOp(ops, this._ctx, key, value, this.comparator);
+    flush();
+  }
+  delete(key, value) {
+    const { ops, flush } = this._createBufferedOps();
+    deleteOp(ops, this._ctx, key, this.comparator, value);
+    flush();
+  }
+  batchInsert(entries) {
+    const { ops, flush } = this._createBufferedOps();
+    batchInsertOp(ops, this._ctx, entries, this.comparator);
+    flush();
+  }
+  bulkLoad(entries) {
+    const { ops, flush } = this._createBufferedOps();
+    bulkLoadOp(ops, this._ctx, entries, this.comparator);
+    flush();
+  }
+  // ─── Head Data ───────────────────────────────────────────────────
+  getHeadData() {
+    const head = this._ops.readHead();
+    if (head === null) {
+      throw new Error("Head not found");
+    }
+    return head.data;
+  }
+  setHeadData(data) {
+    const { ops, flush } = this._createBufferedOps();
+    const head = ops.readHead();
+    if (head === null) {
+      throw new Error("Head not found");
+    }
+    ops.writeHead({
+      root: head.root,
+      order: head.order,
+      data
+    });
+    flush();
+  }
+  // ─── Static utilities ────────────────────────────────────────────
+  static ChooseDriver = BPTreeTransaction.ChooseDriver;
+};
+
+// src/BPTreePureAsync.ts
+var BPTreePureAsync = class {
+  strategy;
+  comparator;
+  option;
+  lock = new Ryoiki2();
+  _cachedRegexp = /* @__PURE__ */ new Map();
+  _ctx;
+  _ops;
+  _verifierMap;
+  _searchConfigs;
+  constructor(strategy, comparator, option) {
+    this.strategy = strategy;
+    this.comparator = comparator;
+    this.option = option ?? {};
+    const ensureValues = (v) => Array.isArray(v) ? v : [v];
+    this._verifierMap = createVerifierMap(comparator, this._cachedRegexp, ensureValues);
+    this._searchConfigs = createSearchConfigsAsync(comparator, ensureValues);
+  }
+  _ensureValues(v) {
+    return Array.isArray(v) ? v : [v];
+  }
+  _createOps() {
+    const strategy = this.strategy;
+    return {
+      async getNode(id) {
+        return await strategy.read(id);
+      },
+      async createNode(leaf, keys, values, parent = null, next = null, prev = null) {
+        const id = await strategy.id(leaf);
+        const node = { id, keys, values, leaf, parent, next, prev };
+        return node;
+      },
+      async updateNode() {
+      },
+      async deleteNode() {
+      },
+      async readHead() {
+        return await strategy.readHead();
+      },
+      async writeHead() {
+      }
+    };
+  }
+  _createBufferedOps() {
+    const strategy = this.strategy;
+    const writeBuffer = /* @__PURE__ */ new Map();
+    const deleteBuffer = /* @__PURE__ */ new Set();
+    let headBuffer = null;
+    const ops = {
+      async getNode(id) {
+        const buffered = writeBuffer.get(id);
+        if (buffered) return buffered;
+        return await strategy.read(id);
+      },
+      async createNode(leaf, keys, values, parent = null, next = null, prev = null) {
+        const id = await strategy.id(leaf);
+        const node = { id, keys, values, leaf, parent, next, prev };
+        writeBuffer.set(id, node);
+        return node;
+      },
+      async updateNode(node) {
+        writeBuffer.set(node.id, node);
+      },
+      async deleteNode(node) {
+        deleteBuffer.add(node.id);
+        writeBuffer.delete(node.id);
+      },
+      async readHead() {
+        if (headBuffer) return headBuffer;
+        return await strategy.readHead();
+      },
+      async writeHead(head) {
+        headBuffer = head;
+      }
+    };
+    async function flush() {
+      for (const id of deleteBuffer) {
+        await strategy.delete(id);
+      }
+      for (const [id, node] of writeBuffer) {
+        await strategy.write(id, node);
+      }
+      if (headBuffer) {
+        await strategy.writeHead(headBuffer);
+      }
+    }
+    return { ops, flush };
+  }
+  async writeLock(fn) {
+    let lockId;
+    return this.lock.writeLock(async (_lockId) => {
+      lockId = _lockId;
+      return fn();
+    }).finally(() => {
+      this.lock.writeUnlock(lockId);
+    });
+  }
+  async init() {
+    return this.writeLock(async () => {
+      const { ops, flush } = this._createBufferedOps();
+      this._ctx = {
+        rootId: "",
+        order: this.strategy.order,
+        headData: () => this.strategy.head.data
+      };
+      await initOpAsync(
+        ops,
+        this._ctx,
+        this.strategy.order,
+        this.strategy.head,
+        (head) => {
+          this.strategy.head = head;
+        }
+      );
+      await flush();
+      this._ops = this._createOps();
+    });
+  }
+  getRootId() {
+    return this._ctx.rootId;
+  }
+  getOrder() {
+    return this._ctx.order;
+  }
+  verify(nodeValue, condition) {
+    for (const key in condition) {
+      const verifyFn = this._verifierMap[key];
+      const condValue = condition[key];
+      if (!verifyFn(nodeValue, condValue)) return false;
+    }
+    return true;
+  }
+  // ─── Query ───────────────────────────────────────────────────────
+  async get(key) {
+    return getOpAsync(this._ops, this._ctx.rootId, key);
+  }
+  async exists(key, value) {
+    return existsOpAsync(this._ops, this._ctx.rootId, key, value, this.comparator);
+  }
+  async *keysStream(condition, options) {
+    let lockId;
+    try {
+      lockId = await this.lock.readLock([0, 0.1], async (id) => id);
+      yield* keysStreamOpAsync(
+        this._ops,
+        this._ctx.rootId,
+        condition,
+        this.comparator,
+        this._verifierMap,
+        this._searchConfigs,
+        this._ensureValues,
+        options
+      );
+    } finally {
+      if (lockId) this.lock.readUnlock(lockId);
+    }
+  }
+  async *whereStream(condition, options) {
+    let lockId;
+    try {
+      lockId = await this.lock.readLock([0, 0.1], async (id) => id);
+      yield* whereStreamOpAsync(
+        this._ops,
+        this._ctx.rootId,
+        condition,
+        this.comparator,
+        this._verifierMap,
+        this._searchConfigs,
+        this._ensureValues,
+        options
+      );
+    } finally {
+      if (lockId) this.lock.readUnlock(lockId);
+    }
+  }
+  async keys(condition, options) {
+    const set = /* @__PURE__ */ new Set();
+    for await (const key of this.keysStream(condition, options)) {
+      set.add(key);
+    }
+    return set;
+  }
+  async where(condition, options) {
+    const map = /* @__PURE__ */ new Map();
+    for await (const [key, value] of this.whereStream(condition, options)) {
+      map.set(key, value);
+    }
+    return map;
+  }
+  // ─── Mutation ────────────────────────────────────────────────────
+  async insert(key, value) {
+    return this.writeLock(async () => {
+      const { ops, flush } = this._createBufferedOps();
+      await insertOpAsync(ops, this._ctx, key, value, this.comparator);
+      await flush();
+    });
+  }
+  async delete(key, value) {
+    return this.writeLock(async () => {
+      const { ops, flush } = this._createBufferedOps();
+      await deleteOpAsync(ops, this._ctx, key, this.comparator, value);
+      await flush();
+    });
+  }
+  async batchInsert(entries) {
+    return this.writeLock(async () => {
+      const { ops, flush } = this._createBufferedOps();
+      await batchInsertOpAsync(ops, this._ctx, entries, this.comparator);
+      await flush();
+    });
+  }
+  async bulkLoad(entries) {
+    return this.writeLock(async () => {
+      const { ops, flush } = this._createBufferedOps();
+      await bulkLoadOpAsync(ops, this._ctx, entries, this.comparator);
+      await flush();
+    });
+  }
+  // ─── Head Data ───────────────────────────────────────────────────
+  async getHeadData() {
+    const head = await this._ops.readHead();
+    if (head === null) throw new Error("Head not found");
+    return head.data;
+  }
+  async setHeadData(data) {
+    return this.writeLock(async () => {
+      const { ops, flush } = this._createBufferedOps();
+      const head = await ops.readHead();
+      if (head === null) throw new Error("Head not found");
+      await ops.writeHead({ root: head.root, order: head.order, data });
+      await flush();
+    });
+  }
+  // ─── Static utilities ────────────────────────────────────────────
+  static ChooseDriver = BPTreeTransaction.ChooseDriver;
+};
+
 // src/base/SerializeStrategy.ts
 var SerializeStrategy = class {
   order;
@@ -4357,6 +5537,8 @@ var InMemoryStoreStrategyAsync = class extends SerializeStrategyAsync {
 export {
   BPTreeAsync,
   BPTreeAsyncTransaction,
+  BPTreePureAsync,
+  BPTreePureSync,
   BPTreeSync,
   BPTreeSyncTransaction,
   InMemoryStoreStrategyAsync,