serializable-bptree 8.3.4 → 8.3.5

package/dist/cjs/index.cjs

@@ -1608,28 +1608,28 @@ var BPTreeTransaction = class _BPTreeTransaction {
   searchConfigs = {
     gt: {
       asc: {
-        start: (tx, v) => tx.insertableRightestNodeByPrimary(v[0]),
+        start: (tx, v) => tx.findUpperBoundLeaf(v[0]),
         end: () => null,
         direction: 1,
         earlyTerminate: false
       },
       desc: {
         start: (tx) => tx.rightestNode(),
-        end: (tx, v) => tx.insertableEndNode(v[0], -1),
+        end: (tx, v) => tx.findOuterBoundaryLeaf(v[0], -1),
         direction: -1,
         earlyTerminate: true
       }
     },
     gte: {
       asc: {
-        start: (tx, v) => tx.insertableNodeByPrimary(v[0]),
+        start: (tx, v) => tx.findLowerBoundLeaf(v[0]),
         end: () => null,
         direction: 1,
         earlyTerminate: false
       },
       desc: {
         start: (tx) => tx.rightestNode(),
-        end: (tx, v) => tx.insertableEndNode(v[0], -1),
+        end: (tx, v) => tx.findOuterBoundaryLeaf(v[0], -1),
         direction: -1,
         earlyTerminate: true
       }
@@ -1637,12 +1637,12 @@ var BPTreeTransaction = class _BPTreeTransaction {
     lt: {
       asc: {
         start: (tx) => tx.leftestNode(),
-        end: (tx, v) => tx.insertableEndNode(v[0], 1),
+        end: (tx, v) => tx.findOuterBoundaryLeaf(v[0], 1),
         direction: 1,
         earlyTerminate: true
       },
       desc: {
-        start: (tx, v) => tx.insertableNodeByPrimary(v[0]),
+        start: (tx, v) => tx.findLowerBoundLeaf(v[0]),
         end: () => null,
         direction: -1,
         earlyTerminate: false
@@ -1651,12 +1651,12 @@ var BPTreeTransaction = class _BPTreeTransaction {
     lte: {
       asc: {
         start: (tx) => tx.leftestNode(),
-        end: (tx, v) => tx.insertableEndNode(v[0], 1),
+        end: (tx, v) => tx.findOuterBoundaryLeaf(v[0], 1),
         direction: 1,
         earlyTerminate: true
       },
       desc: {
-        start: (tx, v) => tx.insertableRightestNodeByPrimary(v[0]),
+        start: (tx, v) => tx.findUpperBoundLeaf(v[0]),
         end: () => null,
         direction: -1,
         earlyTerminate: false
@@ -1664,14 +1664,14 @@ var BPTreeTransaction = class _BPTreeTransaction {
     },
     equal: {
       asc: {
-        start: (tx, v) => tx.insertableNodeByPrimary(v[0]),
-        end: (tx, v) => tx.insertableEndNode(v[0], 1),
+        start: (tx, v) => tx.findLowerBoundLeaf(v[0]),
+        end: (tx, v) => tx.findOuterBoundaryLeaf(v[0], 1),
         direction: 1,
         earlyTerminate: true
       },
       desc: {
-        start: (tx, v) => tx.insertableEndNode(v[0], 1),
-        end: (tx, v) => tx.insertableEndNode(v[0], -1),
+        start: (tx, v) => tx.findOuterBoundaryLeaf(v[0], 1),
+        end: (tx, v) => tx.findOuterBoundaryLeaf(v[0], -1),
         direction: -1,
         earlyTerminate: true
       }
@@ -1692,42 +1692,42 @@ var BPTreeTransaction = class _BPTreeTransaction {
     },
     or: {
       asc: {
-        start: (tx, v) => tx.insertableNodeByPrimary(tx.lowestValue(v)),
-        end: (tx, v) => tx.insertableEndNode(tx.highestValue(v), 1),
+        start: (tx, v) => tx.findLowerBoundLeaf(tx.lowestValue(v)),
+        end: (tx, v) => tx.findOuterBoundaryLeaf(tx.highestValue(v), 1),
         direction: 1,
         earlyTerminate: false
       },
       desc: {
-        start: (tx, v) => tx.insertableEndNode(tx.highestValue(v), 1),
-        end: (tx, v) => tx.insertableEndNode(tx.lowestValue(v), -1),
+        start: (tx, v) => tx.findOuterBoundaryLeaf(tx.highestValue(v), 1),
+        end: (tx, v) => tx.findOuterBoundaryLeaf(tx.lowestValue(v), -1),
         direction: -1,
         earlyTerminate: false
       }
     },
     primaryGt: {
       asc: {
-        start: (tx, v) => tx.insertableRightestNodeByPrimary(v[0]),
+        start: (tx, v) => tx.findUpperBoundLeaf(v[0]),
         end: () => null,
         direction: 1,
         earlyTerminate: false
       },
       desc: {
         start: (tx) => tx.rightestNode(),
-        end: (tx, v) => tx.insertableEndNode(v[0], -1),
+        end: (tx, v) => tx.findOuterBoundaryLeaf(v[0], -1),
         direction: -1,
         earlyTerminate: true
       }
     },
     primaryGte: {
       asc: {
-        start: (tx, v) => tx.insertableNodeByPrimary(v[0]),
+        start: (tx, v) => tx.findLowerBoundLeaf(v[0]),
         end: () => null,
         direction: 1,
         earlyTerminate: false
       },
       desc: {
         start: (tx) => tx.rightestNode(),
-        end: (tx, v) => tx.insertableEndNode(v[0], -1),
+        end: (tx, v) => tx.findOuterBoundaryLeaf(v[0], -1),
         direction: -1,
         earlyTerminate: true
       }
@@ -1735,12 +1735,12 @@ var BPTreeTransaction = class _BPTreeTransaction {
     primaryLt: {
       asc: {
         start: (tx) => tx.leftestNode(),
-        end: (tx, v) => tx.insertableEndNode(v[0], 1),
+        end: (tx, v) => tx.findOuterBoundaryLeaf(v[0], 1),
         direction: 1,
         earlyTerminate: true
       },
       desc: {
-        start: (tx, v) => tx.insertableNodeByPrimary(v[0]),
+        start: (tx, v) => tx.findLowerBoundLeaf(v[0]),
         end: () => null,
         direction: -1,
         earlyTerminate: false
@@ -1749,12 +1749,12 @@ var BPTreeTransaction = class _BPTreeTransaction {
     primaryLte: {
       asc: {
         start: (tx) => tx.leftestNode(),
-        end: (tx, v) => tx.insertableEndNode(v[0], 1),
+        end: (tx, v) => tx.findOuterBoundaryLeaf(v[0], 1),
         direction: 1,
         earlyTerminate: true
       },
       desc: {
-        start: (tx, v) => tx.insertableRightestNodeByPrimary(v[0]),
+        start: (tx, v) => tx.findUpperBoundLeaf(v[0]),
         end: () => null,
         direction: -1,
         earlyTerminate: false
@@ -1762,14 +1762,14 @@ var BPTreeTransaction = class _BPTreeTransaction {
     },
     primaryEqual: {
       asc: {
-        start: (tx, v) => tx.insertableNodeByPrimary(v[0]),
-        end: (tx, v) => tx.insertableRightestEndNodeByPrimary(v[0]),
+        start: (tx, v) => tx.findLowerBoundLeaf(v[0]),
+        end: (tx, v) => tx.findOuterBoundaryLeaf(v[0], 1),
         direction: 1,
         earlyTerminate: true
       },
       desc: {
-        start: (tx, v) => tx.insertableRightestNodeByPrimary(v[0]),
-        end: (tx, v) => tx.insertableEndNode(v[0], -1),
+        start: (tx, v) => tx.findUpperBoundLeaf(v[0]),
+        end: (tx, v) => tx.findOuterBoundaryLeaf(v[0], -1),
         direction: -1,
         earlyTerminate: true
       }
@@ -1790,14 +1790,14 @@ var BPTreeTransaction = class _BPTreeTransaction {
     },
     primaryOr: {
       asc: {
-        start: (tx, v) => tx.insertableNodeByPrimary(tx.lowestPrimaryValue(v)),
-        end: (tx, v) => tx.insertableRightestEndNodeByPrimary(tx.highestPrimaryValue(v)),
+        start: (tx, v) => tx.findLowerBoundLeaf(tx.lowestPrimaryValue(v)),
+        end: (tx, v) => tx.findOuterBoundaryLeaf(tx.highestPrimaryValue(v), 1),
         direction: 1,
         earlyTerminate: false
       },
       desc: {
-        start: (tx, v) => tx.insertableRightestNodeByPrimary(tx.highestPrimaryValue(v)),
-        end: (tx, v) => tx.insertableEndNode(tx.lowestPrimaryValue(v), -1),
+        start: (tx, v) => tx.findUpperBoundLeaf(tx.highestPrimaryValue(v)),
+        end: (tx, v) => tx.findOuterBoundaryLeaf(tx.lowestPrimaryValue(v), -1),
         direction: -1,
         earlyTerminate: false
       }
@@ -1969,17 +1969,19 @@ var BPTreeTransaction = class _BPTreeTransaction {
     let endKey = null;
     let startValues = [];
     let endValues = [];
-    for (const key of startCandidates) {
+    for (let i = 0, len = startCandidates.length; i < len; i++) {
+      const key = startCandidates[i];
       if (key in condition) {
         startKey = key;
-        startValues = this.ensureValues(condition[key]);
+        startValues = _BPTreeTransaction._multiValueKeys.includes(key) ? this.ensureValues(condition[key]) : [condition[key]];
         break;
       }
     }
-    for (const key of endCandidates) {
+    for (let i = 0, len = endCandidates.length; i < len; i++) {
+      const key = endCandidates[i];
       if (key in condition) {
         endKey = key;
-        endValues = this.ensureValues(condition[key]);
+        endValues = _BPTreeTransaction._multiValueKeys.includes(key) ? this.ensureValues(condition[key]) : [condition[key]];
         break;
       }
     }
@@ -2009,6 +2011,11 @@ var BPTreeTransaction = class _BPTreeTransaction {
     "primaryOr",
     "or"
   ];
+  // Condition keys that accept multiple values (V[]) rather than a single value (V)
+  static _multiValueKeys = [
+    "or",
+    "primaryOr"
+  ];
   constructor(rootTx, mvccRoot, mvcc, strategy, comparator, option) {
     this.rootTx = rootTx === null ? this : rootTx;
     this.mvccRoot = mvccRoot;
@@ -2247,7 +2254,7 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
       this._insertInParent(parentNode, midValue, newSiblingNodeRecursive);
     }
   }
-  insertableNode(value) {
+  locateLeaf(value) {
     let node = this.getNode(this.rootId);
     while (!node.leaf) {
       const { index } = this._binarySearchValues(node.values, value, false, true);
@@ -2255,7 +2262,7 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
     }
     return node;
   }
-  insertableNodeByPrimary(value) {
+  findLowerBoundLeaf(value) {
     let node = this.getNode(this.rootId);
     while (!node.leaf) {
       const { index } = this._binarySearchValues(node.values, value, true, false);
@@ -2263,7 +2270,7 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
     }
     return node;
   }
-  insertableRightestNodeByPrimary(value) {
+  findUpperBoundLeaf(value) {
     let node = this.getNode(this.rootId);
     while (!node.leaf) {
       const { index } = this._binarySearchValues(node.values, value, true, true);
@@ -2271,15 +2278,8 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
     }
     return node;
   }
-  insertableRightestEndNodeByPrimary(value) {
-    const node = this.insertableRightestNodeByPrimary(value);
-    if (!node.next) {
-      return null;
-    }
-    return this.getNode(node.next);
-  }
-  insertableEndNode(value, direction) {
-    const insertableNode = direction === -1 ? this.insertableNodeByPrimary(value) : this.insertableRightestNodeByPrimary(value);
+  findOuterBoundaryLeaf(value, direction) {
+    const insertableNode = direction === -1 ? this.findLowerBoundLeaf(value) : this.findUpperBoundLeaf(value);
     let key;
     switch (direction) {
       case -1:
@@ -2391,7 +2391,7 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
     }
   }
   exists(key, value) {
-    const node = this.insertableNode(value);
+    const node = this.locateLeaf(value);
     const { index, found } = this._binarySearchValues(node.values, value);
     if (found) {
       const keys = node.keys[index];
@@ -2488,7 +2488,7 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
     return map;
   }
   insert(key, value) {
-    let before = this.insertableNode(value);
+    let before = this.locateLeaf(value);
     before = this._insertAtLeaf(before, key, value);
     if (before.values.length === this.order) {
       let after = this._createNode(
@@ -2516,7 +2516,7 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
     let currentLeaf = null;
     let modified = false;
     for (const [key, value] of sorted) {
-      const targetLeaf = this.insertableNode(value);
+      const targetLeaf = this.locateLeaf(value);
       if (currentLeaf !== null && currentLeaf.id === targetLeaf.id) {
       } else {
         if (currentLeaf !== null && modified) {
@@ -2758,7 +2758,7 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
     if (value === void 0) {
       return;
     }
-    let node = this.insertableNodeByPrimary(value);
+    let node = this.findLowerBoundLeaf(value);
     let found = false;
     while (true) {
       let i = node.values.length;
@@ -3348,7 +3348,7 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
       await this._insertInParent(parentNode, midValue, newSiblingNodeRecursive);
     }
   }
-  async insertableNode(value) {
+  async locateLeaf(value) {
     let node = await this.getNode(this.rootId);
     while (!node.leaf) {
       const { index } = this._binarySearchValues(node.values, value, false, true);
@@ -3356,7 +3356,7 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
     }
     return node;
   }
-  async insertableNodeByPrimary(value) {
+  async findLowerBoundLeaf(value) {
     let node = await this.getNode(this.rootId);
     while (!node.leaf) {
       const { index } = this._binarySearchValues(node.values, value, true, false);
@@ -3364,7 +3364,7 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
     }
     return node;
   }
-  async insertableRightestNodeByPrimary(value) {
+  async findUpperBoundLeaf(value) {
     let node = await this.getNode(this.rootId);
     while (!node.leaf) {
       const { index } = this._binarySearchValues(node.values, value, true, true);
@@ -3372,15 +3372,8 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
     }
     return node;
   }
-  async insertableRightestEndNodeByPrimary(value) {
-    const node = await this.insertableRightestNodeByPrimary(value);
-    if (!node.next) {
-      return null;
-    }
-    return await this.getNode(node.next);
-  }
-  async insertableEndNode(value, direction) {
-    const insertableNode = direction === -1 ? await this.insertableNodeByPrimary(value) : await this.insertableRightestNodeByPrimary(value);
+  async findOuterBoundaryLeaf(value, direction) {
+    const insertableNode = direction === -1 ? await this.findLowerBoundLeaf(value) : await this.findUpperBoundLeaf(value);
     let key;
     switch (direction) {
       case -1:
@@ -3501,7 +3494,7 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
     }
   }
   async exists(key, value) {
-    const node = await this.insertableNode(value);
+    const node = await this.locateLeaf(value);
     const { index, found } = this._binarySearchValues(node.values, value);
     if (found) {
       const keys = node.keys[index];
@@ -3599,7 +3592,7 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
   }
   async insert(key, value) {
     return this.writeLock(0, async () => {
-      let before = await this.insertableNode(value);
+      let before = await this.locateLeaf(value);
       before = await this._insertAtLeaf(before, key, value);
       if (before.values.length === this.order) {
         let after = await this._createNode(
@@ -3629,7 +3622,7 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
       let currentLeaf = null;
       let modified = false;
       for (const [key, value] of sorted) {
-        const targetLeaf = await this.insertableNode(value);
+        const targetLeaf = await this.locateLeaf(value);
         if (currentLeaf !== null && currentLeaf.id === targetLeaf.id) {
         } else {
           if (currentLeaf !== null && modified) {
@@ -3873,7 +3866,7 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
       if (value === void 0) {
         return;
       }
-      let node = await this.insertableNodeByPrimary(value);
+      let node = await this.findLowerBoundLeaf(value);
       let found = false;
       while (true) {
         let i = node.values.length;

package/dist/esm/index.mjs

@@ -1572,28 +1572,28 @@ var BPTreeTransaction = class _BPTreeTransaction {
   searchConfigs = {
     gt: {
       asc: {
-        start: (tx, v) => tx.insertableRightestNodeByPrimary(v[0]),
+        start: (tx, v) => tx.findUpperBoundLeaf(v[0]),
         end: () => null,
         direction: 1,
         earlyTerminate: false
       },
       desc: {
         start: (tx) => tx.rightestNode(),
-        end: (tx, v) => tx.insertableEndNode(v[0], -1),
+        end: (tx, v) => tx.findOuterBoundaryLeaf(v[0], -1),
         direction: -1,
         earlyTerminate: true
       }
     },
     gte: {
       asc: {
-        start: (tx, v) => tx.insertableNodeByPrimary(v[0]),
+        start: (tx, v) => tx.findLowerBoundLeaf(v[0]),
         end: () => null,
         direction: 1,
         earlyTerminate: false
       },
       desc: {
         start: (tx) => tx.rightestNode(),
-        end: (tx, v) => tx.insertableEndNode(v[0], -1),
+        end: (tx, v) => tx.findOuterBoundaryLeaf(v[0], -1),
         direction: -1,
         earlyTerminate: true
       }
@@ -1601,12 +1601,12 @@ var BPTreeTransaction = class _BPTreeTransaction {
     lt: {
       asc: {
         start: (tx) => tx.leftestNode(),
-        end: (tx, v) => tx.insertableEndNode(v[0], 1),
+        end: (tx, v) => tx.findOuterBoundaryLeaf(v[0], 1),
         direction: 1,
         earlyTerminate: true
       },
       desc: {
-        start: (tx, v) => tx.insertableNodeByPrimary(v[0]),
+        start: (tx, v) => tx.findLowerBoundLeaf(v[0]),
         end: () => null,
         direction: -1,
         earlyTerminate: false
@@ -1615,12 +1615,12 @@ var BPTreeTransaction = class _BPTreeTransaction {
     lte: {
       asc: {
         start: (tx) => tx.leftestNode(),
-        end: (tx, v) => tx.insertableEndNode(v[0], 1),
+        end: (tx, v) => tx.findOuterBoundaryLeaf(v[0], 1),
         direction: 1,
         earlyTerminate: true
       },
       desc: {
-        start: (tx, v) => tx.insertableRightestNodeByPrimary(v[0]),
+        start: (tx, v) => tx.findUpperBoundLeaf(v[0]),
         end: () => null,
         direction: -1,
         earlyTerminate: false
@@ -1628,14 +1628,14 @@ var BPTreeTransaction = class _BPTreeTransaction {
     },
     equal: {
       asc: {
-        start: (tx, v) => tx.insertableNodeByPrimary(v[0]),
-        end: (tx, v) => tx.insertableEndNode(v[0], 1),
+        start: (tx, v) => tx.findLowerBoundLeaf(v[0]),
+        end: (tx, v) => tx.findOuterBoundaryLeaf(v[0], 1),
         direction: 1,
         earlyTerminate: true
       },
       desc: {
-        start: (tx, v) => tx.insertableEndNode(v[0], 1),
-        end: (tx, v) => tx.insertableEndNode(v[0], -1),
+        start: (tx, v) => tx.findOuterBoundaryLeaf(v[0], 1),
+        end: (tx, v) => tx.findOuterBoundaryLeaf(v[0], -1),
         direction: -1,
         earlyTerminate: true
       }
@@ -1656,42 +1656,42 @@ var BPTreeTransaction = class _BPTreeTransaction {
     },
     or: {
       asc: {
-        start: (tx, v) => tx.insertableNodeByPrimary(tx.lowestValue(v)),
-        end: (tx, v) => tx.insertableEndNode(tx.highestValue(v), 1),
+        start: (tx, v) => tx.findLowerBoundLeaf(tx.lowestValue(v)),
+        end: (tx, v) => tx.findOuterBoundaryLeaf(tx.highestValue(v), 1),
         direction: 1,
         earlyTerminate: false
       },
       desc: {
-        start: (tx, v) => tx.insertableEndNode(tx.highestValue(v), 1),
-        end: (tx, v) => tx.insertableEndNode(tx.lowestValue(v), -1),
+        start: (tx, v) => tx.findOuterBoundaryLeaf(tx.highestValue(v), 1),
+        end: (tx, v) => tx.findOuterBoundaryLeaf(tx.lowestValue(v), -1),
         direction: -1,
         earlyTerminate: false
       }
     },
     primaryGt: {
       asc: {
-        start: (tx, v) => tx.insertableRightestNodeByPrimary(v[0]),
+        start: (tx, v) => tx.findUpperBoundLeaf(v[0]),
         end: () => null,
         direction: 1,
         earlyTerminate: false
       },
       desc: {
         start: (tx) => tx.rightestNode(),
-        end: (tx, v) => tx.insertableEndNode(v[0], -1),
+        end: (tx, v) => tx.findOuterBoundaryLeaf(v[0], -1),
         direction: -1,
         earlyTerminate: true
       }
     },
     primaryGte: {
       asc: {
-        start: (tx, v) => tx.insertableNodeByPrimary(v[0]),
+        start: (tx, v) => tx.findLowerBoundLeaf(v[0]),
         end: () => null,
         direction: 1,
         earlyTerminate: false
       },
       desc: {
         start: (tx) => tx.rightestNode(),
-        end: (tx, v) => tx.insertableEndNode(v[0], -1),
+        end: (tx, v) => tx.findOuterBoundaryLeaf(v[0], -1),
         direction: -1,
         earlyTerminate: true
       }
@@ -1699,12 +1699,12 @@ var BPTreeTransaction = class _BPTreeTransaction {
     primaryLt: {
       asc: {
         start: (tx) => tx.leftestNode(),
-        end: (tx, v) => tx.insertableEndNode(v[0], 1),
+        end: (tx, v) => tx.findOuterBoundaryLeaf(v[0], 1),
         direction: 1,
         earlyTerminate: true
       },
       desc: {
-        start: (tx, v) => tx.insertableNodeByPrimary(v[0]),
+        start: (tx, v) => tx.findLowerBoundLeaf(v[0]),
         end: () => null,
         direction: -1,
         earlyTerminate: false
@@ -1713,12 +1713,12 @@ var BPTreeTransaction = class _BPTreeTransaction {
     primaryLte: {
       asc: {
         start: (tx) => tx.leftestNode(),
-        end: (tx, v) => tx.insertableEndNode(v[0], 1),
+        end: (tx, v) => tx.findOuterBoundaryLeaf(v[0], 1),
         direction: 1,
         earlyTerminate: true
       },
       desc: {
-        start: (tx, v) => tx.insertableRightestNodeByPrimary(v[0]),
+        start: (tx, v) => tx.findUpperBoundLeaf(v[0]),
         end: () => null,
         direction: -1,
         earlyTerminate: false
@@ -1726,14 +1726,14 @@ var BPTreeTransaction = class _BPTreeTransaction {
     },
     primaryEqual: {
       asc: {
-        start: (tx, v) => tx.insertableNodeByPrimary(v[0]),
-        end: (tx, v) => tx.insertableRightestEndNodeByPrimary(v[0]),
+        start: (tx, v) => tx.findLowerBoundLeaf(v[0]),
+        end: (tx, v) => tx.findOuterBoundaryLeaf(v[0], 1),
         direction: 1,
         earlyTerminate: true
       },
       desc: {
-        start: (tx, v) => tx.insertableRightestNodeByPrimary(v[0]),
-        end: (tx, v) => tx.insertableEndNode(v[0], -1),
+        start: (tx, v) => tx.findUpperBoundLeaf(v[0]),
+        end: (tx, v) => tx.findOuterBoundaryLeaf(v[0], -1),
         direction: -1,
         earlyTerminate: true
       }
@@ -1754,14 +1754,14 @@ var BPTreeTransaction = class _BPTreeTransaction {
     },
     primaryOr: {
       asc: {
-        start: (tx, v) => tx.insertableNodeByPrimary(tx.lowestPrimaryValue(v)),
-        end: (tx, v) => tx.insertableRightestEndNodeByPrimary(tx.highestPrimaryValue(v)),
+        start: (tx, v) => tx.findLowerBoundLeaf(tx.lowestPrimaryValue(v)),
+        end: (tx, v) => tx.findOuterBoundaryLeaf(tx.highestPrimaryValue(v), 1),
         direction: 1,
         earlyTerminate: false
       },
       desc: {
-        start: (tx, v) => tx.insertableRightestNodeByPrimary(tx.highestPrimaryValue(v)),
-        end: (tx, v) => tx.insertableEndNode(tx.lowestPrimaryValue(v), -1),
+        start: (tx, v) => tx.findUpperBoundLeaf(tx.highestPrimaryValue(v)),
+        end: (tx, v) => tx.findOuterBoundaryLeaf(tx.lowestPrimaryValue(v), -1),
         direction: -1,
         earlyTerminate: false
       }
@@ -1933,17 +1933,19 @@ var BPTreeTransaction = class _BPTreeTransaction {
     let endKey = null;
     let startValues = [];
     let endValues = [];
-    for (const key of startCandidates) {
+    for (let i = 0, len = startCandidates.length; i < len; i++) {
+      const key = startCandidates[i];
       if (key in condition) {
         startKey = key;
-        startValues = this.ensureValues(condition[key]);
+        startValues = _BPTreeTransaction._multiValueKeys.includes(key) ? this.ensureValues(condition[key]) : [condition[key]];
         break;
       }
     }
-    for (const key of endCandidates) {
+    for (let i = 0, len = endCandidates.length; i < len; i++) {
+      const key = endCandidates[i];
       if (key in condition) {
         endKey = key;
-        endValues = this.ensureValues(condition[key]);
+        endValues = _BPTreeTransaction._multiValueKeys.includes(key) ? this.ensureValues(condition[key]) : [condition[key]];
         break;
       }
     }
@@ -1973,6 +1975,11 @@ var BPTreeTransaction = class _BPTreeTransaction {
     "primaryOr",
     "or"
   ];
+  // Condition keys that accept multiple values (V[]) rather than a single value (V)
+  static _multiValueKeys = [
+    "or",
+    "primaryOr"
+  ];
   constructor(rootTx, mvccRoot, mvcc, strategy, comparator, option) {
     this.rootTx = rootTx === null ? this : rootTx;
     this.mvccRoot = mvccRoot;
@@ -2211,7 +2218,7 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
       this._insertInParent(parentNode, midValue, newSiblingNodeRecursive);
     }
   }
-  insertableNode(value) {
+  locateLeaf(value) {
     let node = this.getNode(this.rootId);
     while (!node.leaf) {
       const { index } = this._binarySearchValues(node.values, value, false, true);
@@ -2219,7 +2226,7 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
     }
     return node;
   }
-  insertableNodeByPrimary(value) {
+  findLowerBoundLeaf(value) {
     let node = this.getNode(this.rootId);
     while (!node.leaf) {
       const { index } = this._binarySearchValues(node.values, value, true, false);
@@ -2227,7 +2234,7 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
     }
     return node;
   }
-  insertableRightestNodeByPrimary(value) {
+  findUpperBoundLeaf(value) {
     let node = this.getNode(this.rootId);
     while (!node.leaf) {
       const { index } = this._binarySearchValues(node.values, value, true, true);
@@ -2235,15 +2242,8 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
     }
     return node;
   }
-  insertableRightestEndNodeByPrimary(value) {
-    const node = this.insertableRightestNodeByPrimary(value);
-    if (!node.next) {
-      return null;
-    }
-    return this.getNode(node.next);
-  }
-  insertableEndNode(value, direction) {
-    const insertableNode = direction === -1 ? this.insertableNodeByPrimary(value) : this.insertableRightestNodeByPrimary(value);
+  findOuterBoundaryLeaf(value, direction) {
+    const insertableNode = direction === -1 ? this.findLowerBoundLeaf(value) : this.findUpperBoundLeaf(value);
     let key;
     switch (direction) {
       case -1:
@@ -2355,7 +2355,7 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
     }
   }
   exists(key, value) {
-    const node = this.insertableNode(value);
+    const node = this.locateLeaf(value);
     const { index, found } = this._binarySearchValues(node.values, value);
     if (found) {
       const keys = node.keys[index];
@@ -2452,7 +2452,7 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
     return map;
   }
   insert(key, value) {
-    let before = this.insertableNode(value);
+    let before = this.locateLeaf(value);
     before = this._insertAtLeaf(before, key, value);
     if (before.values.length === this.order) {
       let after = this._createNode(
@@ -2480,7 +2480,7 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
     let currentLeaf = null;
     let modified = false;
     for (const [key, value] of sorted) {
-      const targetLeaf = this.insertableNode(value);
+      const targetLeaf = this.locateLeaf(value);
       if (currentLeaf !== null && currentLeaf.id === targetLeaf.id) {
       } else {
         if (currentLeaf !== null && modified) {
@@ -2722,7 +2722,7 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
     if (value === void 0) {
       return;
     }
-    let node = this.insertableNodeByPrimary(value);
+    let node = this.findLowerBoundLeaf(value);
     let found = false;
     while (true) {
       let i = node.values.length;
@@ -3312,7 +3312,7 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
       await this._insertInParent(parentNode, midValue, newSiblingNodeRecursive);
     }
   }
-  async insertableNode(value) {
+  async locateLeaf(value) {
     let node = await this.getNode(this.rootId);
     while (!node.leaf) {
       const { index } = this._binarySearchValues(node.values, value, false, true);
@@ -3320,7 +3320,7 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
     }
     return node;
   }
-  async insertableNodeByPrimary(value) {
+  async findLowerBoundLeaf(value) {
     let node = await this.getNode(this.rootId);
     while (!node.leaf) {
       const { index } = this._binarySearchValues(node.values, value, true, false);
@@ -3328,7 +3328,7 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
     }
     return node;
   }
-  async insertableRightestNodeByPrimary(value) {
+  async findUpperBoundLeaf(value) {
     let node = await this.getNode(this.rootId);
     while (!node.leaf) {
       const { index } = this._binarySearchValues(node.values, value, true, true);
@@ -3336,15 +3336,8 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
     }
     return node;
   }
-  async insertableRightestEndNodeByPrimary(value) {
-    const node = await this.insertableRightestNodeByPrimary(value);
-    if (!node.next) {
-      return null;
-    }
-    return await this.getNode(node.next);
-  }
-  async insertableEndNode(value, direction) {
-    const insertableNode = direction === -1 ? await this.insertableNodeByPrimary(value) : await this.insertableRightestNodeByPrimary(value);
+  async findOuterBoundaryLeaf(value, direction) {
+    const insertableNode = direction === -1 ? await this.findLowerBoundLeaf(value) : await this.findUpperBoundLeaf(value);
     let key;
     switch (direction) {
       case -1:
@@ -3465,7 +3458,7 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
     }
   }
   async exists(key, value) {
-    const node = await this.insertableNode(value);
+    const node = await this.locateLeaf(value);
     const { index, found } = this._binarySearchValues(node.values, value);
     if (found) {
       const keys = node.keys[index];
@@ -3563,7 +3556,7 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
   }
   async insert(key, value) {
     return this.writeLock(0, async () => {
-      let before = await this.insertableNode(value);
+      let before = await this.locateLeaf(value);
       before = await this._insertAtLeaf(before, key, value);
       if (before.values.length === this.order) {
         let after = await this._createNode(
@@ -3593,7 +3586,7 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
       let currentLeaf = null;
       let modified = false;
       for (const [key, value] of sorted) {
-        const targetLeaf = await this.insertableNode(value);
+        const targetLeaf = await this.locateLeaf(value);
         if (currentLeaf !== null && currentLeaf.id === targetLeaf.id) {
         } else {
           if (currentLeaf !== null && modified) {
@@ -3837,7 +3830,7 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
       if (value === void 0) {
         return;
       }
-      let node = await this.insertableNodeByPrimary(value);
+      let node = await this.findLowerBoundLeaf(value);
       let found = false;
       while (true) {
         let i = node.values.length;

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

@@ -103,17 +103,17 @@ export declare abstract class BPTreeTransaction<K, V> {
     };
     private static readonly _lowerBoundKeys;
     private static readonly _upperBoundKeys;
+    private static readonly _multiValueKeys;
     protected constructor(rootTx: BPTreeTransaction<K, V> | null, mvccRoot: BPTreeMVCC<K, V>, mvcc: BPTreeMVCC<K, V>, strategy: SerializeStrategy<K, V>, comparator: ValueComparator<V>, option?: BPTreeConstructorOption);
     protected abstract _createNode(leaf: boolean, keys: string[] | K[][], values: V[], parent?: string | null, next?: string | null, prev?: string | null): Deferred<BPTreeUnknownNode<K, V>>;
     protected abstract _deleteEntry(node: BPTreeUnknownNode<K, V>, key: BPTreeNodeKey<K>): Deferred<BPTreeUnknownNode<K, V>>;
     protected abstract _insertInParent(node: BPTreeUnknownNode<K, V>, value: V, pointer: BPTreeUnknownNode<K, V>): Deferred<void>;
     protected abstract _insertAtLeaf(node: BPTreeUnknownNode<K, V>, key: BPTreeNodeKey<K>, value: V): Deferred<BPTreeUnknownNode<K, V>>;
     protected abstract getNode(id: string): Deferred<BPTreeUnknownNode<K, V>>;
-    protected abstract insertableNode(value: V): Deferred<BPTreeLeafNode<K, V>>;
-    protected abstract insertableNodeByPrimary(value: V): Deferred<BPTreeLeafNode<K, V>>;
-    protected abstract insertableRightestNodeByPrimary(value: V): Deferred<BPTreeLeafNode<K, V>>;
-    protected abstract insertableRightestEndNodeByPrimary(value: V): Deferred<BPTreeLeafNode<K, V> | null>;
-    protected abstract insertableEndNode(value: V, direction: 1 | -1): Deferred<BPTreeLeafNode<K, V> | null>;
+    protected abstract locateLeaf(value: V): Deferred<BPTreeLeafNode<K, V>>;
+    protected abstract findLowerBoundLeaf(value: V): Deferred<BPTreeLeafNode<K, V>>;
+    protected abstract findUpperBoundLeaf(value: V): Deferred<BPTreeLeafNode<K, V>>;
+    protected abstract findOuterBoundaryLeaf(value: V, direction: 1 | -1): Deferred<BPTreeLeafNode<K, V> | null>;
     protected abstract leftestNode(): Deferred<BPTreeLeafNode<K, V>>;
     protected abstract rightestNode(): Deferred<BPTreeLeafNode<K, V>>;
     /**

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

@@ -25,11 +25,10 @@ export declare class BPTreeAsyncTransaction<K, V> extends BPTreeTransaction<K, V
     protected _writeHead(head: SerializeStrategyHead): Promise<void>;
     protected _insertAtLeaf(node: BPTreeUnknownNode<K, V>, key: BPTreeNodeKey<K>, value: V): Promise<BPTreeUnknownNode<K, V>>;
     protected _insertInParent(node: BPTreeUnknownNode<K, V>, value: V, newSiblingNode: BPTreeUnknownNode<K, V>): Promise<void>;
-    protected insertableNode(value: V): Promise<BPTreeLeafNode<K, V>>;
-    protected insertableNodeByPrimary(value: V): Promise<BPTreeLeafNode<K, V>>;
-    protected insertableRightestNodeByPrimary(value: V): Promise<BPTreeLeafNode<K, V>>;
-    protected insertableRightestEndNodeByPrimary(value: V): Promise<BPTreeLeafNode<K, V> | null>;
-    protected insertableEndNode(value: V, direction: 1 | -1): Promise<BPTreeLeafNode<K, V> | null>;
+    protected locateLeaf(value: V): Promise<BPTreeLeafNode<K, V>>;
+    protected findLowerBoundLeaf(value: V): Promise<BPTreeLeafNode<K, V>>;
+    protected findUpperBoundLeaf(value: V): Promise<BPTreeLeafNode<K, V>>;
+    protected findOuterBoundaryLeaf(value: V, direction: 1 | -1): Promise<BPTreeLeafNode<K, V> | null>;
     protected leftestNode(): Promise<BPTreeLeafNode<K, V>>;
     protected rightestNode(): Promise<BPTreeLeafNode<K, V>>;
     protected getPairsGenerator(startNode: BPTreeLeafNode<K, V>, endNode: BPTreeLeafNode<K, V> | null, direction: 1 | -1): AsyncGenerator<[K, V]>;

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

@@ -22,11 +22,10 @@ export declare class BPTreeSyncTransaction<K, V> extends BPTreeTransaction<K, V>
     protected _writeHead(head: SerializeStrategyHead): void;
     protected _insertAtLeaf(node: BPTreeUnknownNode<K, V>, key: BPTreeNodeKey<K>, value: V): BPTreeUnknownNode<K, V>;
     protected _insertInParent(node: BPTreeUnknownNode<K, V>, value: V, newSiblingNode: BPTreeUnknownNode<K, V>): void;
-    protected insertableNode(value: V): BPTreeLeafNode<K, V>;
-    protected insertableNodeByPrimary(value: V): BPTreeLeafNode<K, V>;
-    protected insertableRightestNodeByPrimary(value: V): BPTreeLeafNode<K, V>;
-    protected insertableRightestEndNodeByPrimary(value: V): BPTreeLeafNode<K, V> | null;
-    protected insertableEndNode(value: V, direction: 1 | -1): BPTreeLeafNode<K, V> | null;
+    protected locateLeaf(value: V): BPTreeLeafNode<K, V>;
+    protected findLowerBoundLeaf(value: V): BPTreeLeafNode<K, V>;
+    protected findUpperBoundLeaf(value: V): BPTreeLeafNode<K, V>;
+    protected findOuterBoundaryLeaf(value: V, direction: 1 | -1): BPTreeLeafNode<K, V> | null;
     protected leftestNode(): BPTreeLeafNode<K, V>;
     protected rightestNode(): BPTreeLeafNode<K, V>;
     protected getPairsGenerator(startNode: BPTreeLeafNode<K, V>, endNode: BPTreeLeafNode<K, V> | null, direction: 1 | -1): Generator<[K, V]>;

package/package.json

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