serializable-bptree 8.3.3 → 8.3.4

package/dist/cjs/index.cjs

@@ -94,39 +94,125 @@ var StringComparator = class extends ValueComparator {
 var MVCCStrategy = class {
 };
 var LRUMap = class {
-  cache = /* @__PURE__ */ new Map();
   capacity;
+  map;
+  head = null;
+  tail = null;
+  /**
+   * Creates an instance of LRUMap.
+   * @param capacity The maximum number of items the cache can hold.
+   */
   constructor(capacity) {
     this.capacity = capacity;
+    this.map = /* @__PURE__ */ new Map();
   }
-  get(key) {
-    if (!this.cache.has(key)) return void 0;
-    const value = this.cache.get(key);
-    this.cache.delete(key);
-    this.cache.set(key, value);
-    return value;
+  /**
+   * Promotes a node to the head of the linked list (marks as most recently used).
+   * @param node The node to promote.
+   */
+  promote(node) {
+    this.extract(node);
+    this.prepend(node);
   }
+  /**
+   * Disconnects a node from the doubly linked list.
+   * @param node The node to extract.
+   */
+  extract(node) {
+    if (node.prev) node.prev.next = node.next;
+    else this.head = node.next;
+    if (node.next) node.next.prev = node.prev;
+    else this.tail = node.prev;
+    node.prev = null;
+    node.next = null;
+  }
+  /**
+   * Inserts a node at the head of the doubly linked list.
+   * @param node The node to prepend.
+   */
+  prepend(node) {
+    node.next = this.head;
+    if (this.head) this.head.prev = node;
+    this.head = node;
+    if (!this.tail) this.tail = node;
+  }
+  /**
+   * Stores or updates a value by key.
+   * If the capacity is exceeded, the least recently used item (tail) is removed.
+   * @param key The key to store.
+   * @param value The value to store.
+   */
   set(key, value) {
-    if (this.cache.has(key)) {
-      this.cache.delete(key);
-    } else if (this.cache.size >= this.capacity) {
-      const oldestKey = this.cache.keys().next().value;
-      if (oldestKey !== void 0) this.cache.delete(oldestKey);
+    const existing = this.map.get(key);
+    if (existing) {
+      existing.value = value;
+      this.promote(existing);
+      return;
     }
-    this.cache.set(key, value);
-    return this;
+    const newNode = { key, value, prev: null, next: null };
+    this.map.set(key, newNode);
+    this.prepend(newNode);
+    if (this.map.size > this.capacity && this.tail) {
+      this.map.delete(this.tail.key);
+      this.extract(this.tail);
+    }
+  }
+  /**
+   * Retrieves a value by key.
+   * Accessing the item moves it to the "most recently used" position.
+   * @param key The key to look for.
+   * @returns The value associated with the key, or undefined if not found.
+   */
+  get(key) {
+    const node = this.map.get(key);
+    if (!node) return void 0;
+    this.promote(node);
+    return node.value;
   }
+  /**
+   * Checks if a key exists in the cache without changing its access order.
+   * @param key The key to check.
+   * @returns True if the key exists, false otherwise.
+   */
   has(key) {
-    return this.cache.has(key);
+    return this.map.has(key);
   }
+  /**
+   * Removes a key and its associated value from the cache.
+   * @param key The key to remove.
+   * @returns True if the key was found and removed, false otherwise.
+   */
   delete(key) {
-    return this.cache.delete(key);
+    const node = this.map.get(key);
+    if (!node) return false;
+    this.extract(node);
+    this.map.delete(key);
+    return true;
   }
-  clear() {
-    this.cache.clear();
+  /**
+   * Returns an iterator of keys in the order of most recently used to least recently used.
+   * @returns An iterable iterator of keys.
+   */
+  *keys() {
+    let current = this.head;
+    while (current) {
+      yield current.key;
+      current = current.next;
+    }
   }
+  /**
+   * Returns the current number of items in the cache.
+   */
   get size() {
-    return this.cache.size;
+    return this.map.size;
+  }
+  /**
+   * Clears all items from the cache.
+   */
+  clear() {
+    this.map.clear();
+    this.head = null;
+    this.tail = null;
   }
 };
 var MVCCTransaction = class {
@@ -1522,7 +1608,7 @@ var BPTreeTransaction = class _BPTreeTransaction {
   searchConfigs = {
     gt: {
       asc: {
-        start: (tx, v) => tx.insertableNodeByPrimary(v[0]),
+        start: (tx, v) => tx.insertableRightestNodeByPrimary(v[0]),
         end: () => null,
         direction: 1,
         earlyTerminate: false
@@ -1620,7 +1706,7 @@ var BPTreeTransaction = class _BPTreeTransaction {
     },
     primaryGt: {
       asc: {
-        start: (tx, v) => tx.insertableRightestEndNodeByPrimary(v[0]),
+        start: (tx, v) => tx.insertableRightestNodeByPrimary(v[0]),
         end: () => null,
         direction: 1,
         earlyTerminate: false
@@ -1682,7 +1768,7 @@ var BPTreeTransaction = class _BPTreeTransaction {
         earlyTerminate: true
       },
       desc: {
-        start: (tx, v) => tx.insertableRightestEndNodeByPrimary(v[0]),
+        start: (tx, v) => tx.insertableRightestNodeByPrimary(v[0]),
         end: (tx, v) => tx.insertableEndNode(v[0], -1),
         direction: -1,
         earlyTerminate: true
@@ -1710,7 +1796,7 @@ var BPTreeTransaction = class _BPTreeTransaction {
         earlyTerminate: false
       },
       desc: {
-        start: (tx, v) => tx.insertableRightestEndNodeByPrimary(tx.highestPrimaryValue(v)),
+        start: (tx, v) => tx.insertableRightestNodeByPrimary(tx.highestPrimaryValue(v)),
         end: (tx, v) => tx.insertableEndNode(tx.lowestPrimaryValue(v), -1),
         direction: -1,
         earlyTerminate: false
@@ -1867,30 +1953,62 @@ var BPTreeTransaction = class _BPTreeTransaction {
     return JSON.parse(JSON.stringify(node));
   }
   /**
-   * Selects the best driver key from a condition object.
-   * The driver key determines the starting point and traversal direction for queries.
-   * 
+   * 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.
-   * @returns The best driver key or null if no valid key found.
+   * @param order The sort order ('asc' or 'desc').
+   * @returns The resolved start/end keys, values, and traversal direction.
    */
-  getDriverKey(condition) {
-    if ("primaryEqual" in condition) return "primaryEqual";
-    if ("equal" in condition) return "equal";
-    if ("gt" in condition) return "gt";
-    if ("gte" in condition) return "gte";
-    if ("lt" in condition) return "lt";
-    if ("lte" in condition) return "lte";
-    if ("primaryGt" in condition) return "primaryGt";
-    if ("primaryGte" in condition) return "primaryGte";
-    if ("primaryLt" in condition) return "primaryLt";
-    if ("primaryLte" in condition) return "primaryLte";
-    if ("like" in condition) return "like";
-    if ("notEqual" in condition) return "notEqual";
-    if ("primaryNotEqual" in condition) return "primaryNotEqual";
-    if ("or" in condition) return "or";
-    if ("primaryOr" in condition) return "primaryOr";
-    return null;
-  }
+  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 (const key of startCandidates) {
+      if (key in condition) {
+        startKey = key;
+        startValues = this.ensureValues(condition[key]);
+        break;
+      }
+    }
+    for (const key of endCandidates) {
+      if (key in condition) {
+        endKey = key;
+        endValues = this.ensureValues(condition[key]);
+        break;
+      }
+    }
+    return { startKey, endKey, startValues, endValues, direction };
+  }
+  // Lower bound providers, ordered by selectivity (tightest first)
+  // Used for asc start / desc end
+  static _lowerBoundKeys = [
+    "primaryEqual",
+    "equal",
+    "primaryGt",
+    "gt",
+    "primaryGte",
+    "gte",
+    "primaryOr",
+    "or"
+  ];
+  // Upper bound providers, ordered by selectivity (tightest first)
+  // Used for asc end / desc start
+  static _upperBoundKeys = [
+    "primaryEqual",
+    "equal",
+    "primaryLt",
+    "lt",
+    "primaryLte",
+    "lte",
+    "primaryOr",
+    "or"
+  ];
   constructor(rootTx, mvccRoot, mvcc, strategy, comparator, option) {
     this.rootTx = rootTx === null ? this : rootTx;
     this.mvccRoot = mvccRoot;
@@ -2198,13 +2316,10 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
     }
     return node;
   }
-  *getPairsGenerator(value, startNode, endNode, comparator, direction, earlyTerminate) {
+  *getPairsGenerator(startNode, endNode, direction) {
     let node = startNode;
-    let done = false;
-    let hasMatched = false;
-    while (!done) {
+    while (true) {
       if (endNode && node.id === endNode.id) {
-        done = true;
         break;
       }
       const len = node.values.length;
@@ -2212,14 +2327,8 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
         for (let i = 0; i < len; i++) {
           const nValue = node.values[i];
           const keys = node.keys[i];
-          if (comparator(nValue, value)) {
-            hasMatched = true;
-            for (let j = 0; j < keys.length; j++) {
-              yield [keys[j], nValue];
-            }
-          } else if (earlyTerminate && hasMatched) {
-            done = true;
-            break;
+          for (let j = 0, kLen = keys.length; j < kLen; j++) {
+            yield [keys[j], nValue];
           }
         }
       } else {
@@ -2227,30 +2336,17 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
         while (i--) {
           const nValue = node.values[i];
           const keys = node.keys[i];
-          if (comparator(nValue, value)) {
-            hasMatched = true;
-            let j = keys.length;
-            while (j--) {
-              yield [keys[j], nValue];
-            }
-          } else if (earlyTerminate && hasMatched) {
-            done = true;
-            break;
+          let j = keys.length;
+          while (j--) {
+            yield [keys[j], nValue];
           }
         }
       }
-      if (done) break;
       if (direction === 1) {
-        if (!node.next) {
-          done = true;
-          break;
-        }
+        if (!node.next) break;
         node = this.getNode(node.next);
       } else {
-        if (!node.prev) {
-          done = true;
-          break;
-        }
+        if (!node.prev) break;
         node = this.getNode(node.prev);
       }
     }
@@ -2339,49 +2435,36 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
   }
   *whereStream(condition, options) {
     const { filterValues, limit, order = "asc" } = options ?? {};
-    const driverKey = this.getDriverKey(condition);
-    if (!driverKey) return;
-    const value = condition[driverKey];
-    const v = this.ensureValues(value);
-    const config = this.searchConfigs[driverKey][order];
-    let startNode = config.start(this, v);
-    let endNode = config.end(this, v);
-    const direction = config.direction;
-    const earlyTerminate = config.earlyTerminate;
-    if (order === "desc" && !startNode) {
-      startNode = this.rightestNode();
-    }
-    if (order === "asc" && !startNode) {
-      startNode = this.leftestNode();
+    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 comparator = this.verifierMap[driverKey];
     const generator = this.getPairsGenerator(
-      value,
       startNode,
       endNode,
-      comparator,
-      direction,
-      earlyTerminate
+      direction
     );
     let count = 0;
     const intersection = filterValues && filterValues.size > 0 ? filterValues : null;
     for (const pair of generator) {
-      const [k, v2] = pair;
+      const [k, v] = pair;
       if (intersection && !intersection.has(k)) {
         continue;
       }
-      let isMatch = true;
-      for (const key in condition) {
-        if (key === driverKey) continue;
-        const verify = this.verifierMap[key];
-        const condValue = condition[key];
-        if (!verify(v2, condValue)) {
-          isMatch = false;
-          break;
-        }
-      }
-      if (isMatch) {
+      if (this.verify(v, condition)) {
         yield pair;
         count++;
         if (limit !== void 0 && count >= limit) {
@@ -3334,22 +3417,19 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
     }
     return node;
   }
-  async *getPairsGenerator(value, startNode, endNode, comparator, direction, earlyTerminate) {
+  async *getPairsGenerator(startNode, endNode, direction) {
     let node = startNode;
-    let done = false;
-    let hasMatched = false;
     let nextNodePromise = null;
-    while (!done) {
+    while (true) {
       if (endNode && node.id === endNode.id) {
-        done = true;
         break;
       }
       if (direction === 1) {
-        if (node.next && !done) {
+        if (node.next) {
           nextNodePromise = this.getNode(node.next);
         }
       } else {
-        if (node.prev && !done) {
+        if (node.prev) {
           nextNodePromise = this.getNode(node.prev);
         }
       }
@@ -3358,14 +3438,8 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
         for (let i = 0; i < len; i++) {
           const nValue = node.values[i];
           const keys = node.keys[i];
-          if (comparator(nValue, value)) {
-            hasMatched = true;
-            for (let j = 0; j < keys.length; j++) {
-              yield [keys[j], nValue];
-            }
-          } else if (earlyTerminate && hasMatched) {
-            done = true;
-            break;
+          for (let j = 0, kLen = keys.length; j < kLen; j++) {
+            yield [keys[j], nValue];
           }
         }
       } else {
@@ -3373,27 +3447,17 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
         while (i--) {
           const nValue = node.values[i];
           const keys = node.keys[i];
-          if (comparator(nValue, value)) {
-            hasMatched = true;
-            let j = keys.length;
-            while (j--) {
-              yield [keys[j], nValue];
-            }
-          } else if (earlyTerminate && hasMatched) {
-            done = true;
-            break;
+          let j = keys.length;
+          while (j--) {
+            yield [keys[j], nValue];
           }
         }
       }
-      if (done) {
-        if (nextNodePromise) await nextNodePromise;
-        break;
-      }
       if (nextNodePromise) {
         node = await nextNodePromise;
         nextNodePromise = null;
       } else {
-        done = true;
+        break;
       }
     }
   }
@@ -3481,49 +3545,36 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
   }
   async *whereStream(condition, options) {
     const { filterValues, limit, order = "asc" } = options ?? {};
-    const driverKey = this.getDriverKey(condition);
-    if (!driverKey) return;
-    const value = condition[driverKey];
-    const v = this.ensureValues(value);
-    const config = this.searchConfigs[driverKey][order];
-    let startNode = await config.start(this, v);
-    let endNode = await config.end(this, v);
-    const direction = config.direction;
-    const earlyTerminate = config.earlyTerminate;
-    if (order === "desc" && !startNode) {
-      startNode = await this.rightestNode();
-    }
-    if (order === "asc" && !startNode) {
-      startNode = await this.leftestNode();
+    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 comparator = this.verifierMap[driverKey];
     const generator = this.getPairsGenerator(
-      value,
       startNode,
       endNode,
-      comparator,
-      direction,
-      earlyTerminate
+      direction
     );
     let count = 0;
     const intersection = filterValues && filterValues.size > 0 ? filterValues : null;
     for await (const pair of generator) {
-      const [k, v2] = pair;
+      const [k, v] = pair;
       if (intersection && !intersection.has(k)) {
         continue;
       }
-      let isMatch = true;
-      for (const key in condition) {
-        if (key === driverKey) continue;
-        const verify = this.verifierMap[key];
-        const condValue = condition[key];
-        if (!verify(v2, condValue)) {
-          isMatch = false;
-          break;
-        }
-      }
-      if (isMatch) {
+      if (this.verify(v, condition)) {
         yield pair;
         count++;
         if (limit !== void 0 && count >= limit) {

package/dist/esm/index.mjs

@@ -58,39 +58,125 @@ var StringComparator = class extends ValueComparator {
 var MVCCStrategy = class {
 };
 var LRUMap = class {
-  cache = /* @__PURE__ */ new Map();
   capacity;
+  map;
+  head = null;
+  tail = null;
+  /**
+   * Creates an instance of LRUMap.
+   * @param capacity The maximum number of items the cache can hold.
+   */
   constructor(capacity) {
     this.capacity = capacity;
+    this.map = /* @__PURE__ */ new Map();
   }
-  get(key) {
-    if (!this.cache.has(key)) return void 0;
-    const value = this.cache.get(key);
-    this.cache.delete(key);
-    this.cache.set(key, value);
-    return value;
+  /**
+   * Promotes a node to the head of the linked list (marks as most recently used).
+   * @param node The node to promote.
+   */
+  promote(node) {
+    this.extract(node);
+    this.prepend(node);
   }
+  /**
+   * Disconnects a node from the doubly linked list.
+   * @param node The node to extract.
+   */
+  extract(node) {
+    if (node.prev) node.prev.next = node.next;
+    else this.head = node.next;
+    if (node.next) node.next.prev = node.prev;
+    else this.tail = node.prev;
+    node.prev = null;
+    node.next = null;
+  }
+  /**
+   * Inserts a node at the head of the doubly linked list.
+   * @param node The node to prepend.
+   */
+  prepend(node) {
+    node.next = this.head;
+    if (this.head) this.head.prev = node;
+    this.head = node;
+    if (!this.tail) this.tail = node;
+  }
+  /**
+   * Stores or updates a value by key.
+   * If the capacity is exceeded, the least recently used item (tail) is removed.
+   * @param key The key to store.
+   * @param value The value to store.
+   */
   set(key, value) {
-    if (this.cache.has(key)) {
-      this.cache.delete(key);
-    } else if (this.cache.size >= this.capacity) {
-      const oldestKey = this.cache.keys().next().value;
-      if (oldestKey !== void 0) this.cache.delete(oldestKey);
+    const existing = this.map.get(key);
+    if (existing) {
+      existing.value = value;
+      this.promote(existing);
+      return;
     }
-    this.cache.set(key, value);
-    return this;
+    const newNode = { key, value, prev: null, next: null };
+    this.map.set(key, newNode);
+    this.prepend(newNode);
+    if (this.map.size > this.capacity && this.tail) {
+      this.map.delete(this.tail.key);
+      this.extract(this.tail);
+    }
+  }
+  /**
+   * Retrieves a value by key.
+   * Accessing the item moves it to the "most recently used" position.
+   * @param key The key to look for.
+   * @returns The value associated with the key, or undefined if not found.
+   */
+  get(key) {
+    const node = this.map.get(key);
+    if (!node) return void 0;
+    this.promote(node);
+    return node.value;
   }
+  /**
+   * Checks if a key exists in the cache without changing its access order.
+   * @param key The key to check.
+   * @returns True if the key exists, false otherwise.
+   */
   has(key) {
-    return this.cache.has(key);
+    return this.map.has(key);
   }
+  /**
+   * Removes a key and its associated value from the cache.
+   * @param key The key to remove.
+   * @returns True if the key was found and removed, false otherwise.
+   */
   delete(key) {
-    return this.cache.delete(key);
+    const node = this.map.get(key);
+    if (!node) return false;
+    this.extract(node);
+    this.map.delete(key);
+    return true;
   }
-  clear() {
-    this.cache.clear();
+  /**
+   * Returns an iterator of keys in the order of most recently used to least recently used.
+   * @returns An iterable iterator of keys.
+   */
+  *keys() {
+    let current = this.head;
+    while (current) {
+      yield current.key;
+      current = current.next;
+    }
   }
+  /**
+   * Returns the current number of items in the cache.
+   */
   get size() {
-    return this.cache.size;
+    return this.map.size;
+  }
+  /**
+   * Clears all items from the cache.
+   */
+  clear() {
+    this.map.clear();
+    this.head = null;
+    this.tail = null;
   }
 };
 var MVCCTransaction = class {
@@ -1486,7 +1572,7 @@ var BPTreeTransaction = class _BPTreeTransaction {
   searchConfigs = {
     gt: {
       asc: {
-        start: (tx, v) => tx.insertableNodeByPrimary(v[0]),
+        start: (tx, v) => tx.insertableRightestNodeByPrimary(v[0]),
         end: () => null,
         direction: 1,
         earlyTerminate: false
@@ -1584,7 +1670,7 @@ var BPTreeTransaction = class _BPTreeTransaction {
     },
     primaryGt: {
       asc: {
-        start: (tx, v) => tx.insertableRightestEndNodeByPrimary(v[0]),
+        start: (tx, v) => tx.insertableRightestNodeByPrimary(v[0]),
         end: () => null,
         direction: 1,
         earlyTerminate: false
@@ -1646,7 +1732,7 @@ var BPTreeTransaction = class _BPTreeTransaction {
         earlyTerminate: true
       },
       desc: {
-        start: (tx, v) => tx.insertableRightestEndNodeByPrimary(v[0]),
+        start: (tx, v) => tx.insertableRightestNodeByPrimary(v[0]),
         end: (tx, v) => tx.insertableEndNode(v[0], -1),
         direction: -1,
         earlyTerminate: true
@@ -1674,7 +1760,7 @@ var BPTreeTransaction = class _BPTreeTransaction {
         earlyTerminate: false
       },
       desc: {
-        start: (tx, v) => tx.insertableRightestEndNodeByPrimary(tx.highestPrimaryValue(v)),
+        start: (tx, v) => tx.insertableRightestNodeByPrimary(tx.highestPrimaryValue(v)),
         end: (tx, v) => tx.insertableEndNode(tx.lowestPrimaryValue(v), -1),
         direction: -1,
         earlyTerminate: false
@@ -1831,30 +1917,62 @@ var BPTreeTransaction = class _BPTreeTransaction {
     return JSON.parse(JSON.stringify(node));
   }
   /**
-   * Selects the best driver key from a condition object.
-   * The driver key determines the starting point and traversal direction for queries.
-   * 
+   * 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.
-   * @returns The best driver key or null if no valid key found.
+   * @param order The sort order ('asc' or 'desc').
+   * @returns The resolved start/end keys, values, and traversal direction.
    */
-  getDriverKey(condition) {
-    if ("primaryEqual" in condition) return "primaryEqual";
-    if ("equal" in condition) return "equal";
-    if ("gt" in condition) return "gt";
-    if ("gte" in condition) return "gte";
-    if ("lt" in condition) return "lt";
-    if ("lte" in condition) return "lte";
-    if ("primaryGt" in condition) return "primaryGt";
-    if ("primaryGte" in condition) return "primaryGte";
-    if ("primaryLt" in condition) return "primaryLt";
-    if ("primaryLte" in condition) return "primaryLte";
-    if ("like" in condition) return "like";
-    if ("notEqual" in condition) return "notEqual";
-    if ("primaryNotEqual" in condition) return "primaryNotEqual";
-    if ("or" in condition) return "or";
-    if ("primaryOr" in condition) return "primaryOr";
-    return null;
-  }
+  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 (const key of startCandidates) {
+      if (key in condition) {
+        startKey = key;
+        startValues = this.ensureValues(condition[key]);
+        break;
+      }
+    }
+    for (const key of endCandidates) {
+      if (key in condition) {
+        endKey = key;
+        endValues = this.ensureValues(condition[key]);
+        break;
+      }
+    }
+    return { startKey, endKey, startValues, endValues, direction };
+  }
+  // Lower bound providers, ordered by selectivity (tightest first)
+  // Used for asc start / desc end
+  static _lowerBoundKeys = [
+    "primaryEqual",
+    "equal",
+    "primaryGt",
+    "gt",
+    "primaryGte",
+    "gte",
+    "primaryOr",
+    "or"
+  ];
+  // Upper bound providers, ordered by selectivity (tightest first)
+  // Used for asc end / desc start
+  static _upperBoundKeys = [
+    "primaryEqual",
+    "equal",
+    "primaryLt",
+    "lt",
+    "primaryLte",
+    "lte",
+    "primaryOr",
+    "or"
+  ];
   constructor(rootTx, mvccRoot, mvcc, strategy, comparator, option) {
     this.rootTx = rootTx === null ? this : rootTx;
     this.mvccRoot = mvccRoot;
@@ -2162,13 +2280,10 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
     }
     return node;
   }
-  *getPairsGenerator(value, startNode, endNode, comparator, direction, earlyTerminate) {
+  *getPairsGenerator(startNode, endNode, direction) {
     let node = startNode;
-    let done = false;
-    let hasMatched = false;
-    while (!done) {
+    while (true) {
       if (endNode && node.id === endNode.id) {
-        done = true;
         break;
       }
       const len = node.values.length;
@@ -2176,14 +2291,8 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
         for (let i = 0; i < len; i++) {
           const nValue = node.values[i];
           const keys = node.keys[i];
-          if (comparator(nValue, value)) {
-            hasMatched = true;
-            for (let j = 0; j < keys.length; j++) {
-              yield [keys[j], nValue];
-            }
-          } else if (earlyTerminate && hasMatched) {
-            done = true;
-            break;
+          for (let j = 0, kLen = keys.length; j < kLen; j++) {
+            yield [keys[j], nValue];
           }
         }
       } else {
@@ -2191,30 +2300,17 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
         while (i--) {
           const nValue = node.values[i];
           const keys = node.keys[i];
-          if (comparator(nValue, value)) {
-            hasMatched = true;
-            let j = keys.length;
-            while (j--) {
-              yield [keys[j], nValue];
-            }
-          } else if (earlyTerminate && hasMatched) {
-            done = true;
-            break;
+          let j = keys.length;
+          while (j--) {
+            yield [keys[j], nValue];
           }
         }
       }
-      if (done) break;
       if (direction === 1) {
-        if (!node.next) {
-          done = true;
-          break;
-        }
+        if (!node.next) break;
         node = this.getNode(node.next);
       } else {
-        if (!node.prev) {
-          done = true;
-          break;
-        }
+        if (!node.prev) break;
         node = this.getNode(node.prev);
       }
     }
@@ -2303,49 +2399,36 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
   }
   *whereStream(condition, options) {
     const { filterValues, limit, order = "asc" } = options ?? {};
-    const driverKey = this.getDriverKey(condition);
-    if (!driverKey) return;
-    const value = condition[driverKey];
-    const v = this.ensureValues(value);
-    const config = this.searchConfigs[driverKey][order];
-    let startNode = config.start(this, v);
-    let endNode = config.end(this, v);
-    const direction = config.direction;
-    const earlyTerminate = config.earlyTerminate;
-    if (order === "desc" && !startNode) {
-      startNode = this.rightestNode();
-    }
-    if (order === "asc" && !startNode) {
-      startNode = this.leftestNode();
+    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 comparator = this.verifierMap[driverKey];
     const generator = this.getPairsGenerator(
-      value,
       startNode,
       endNode,
-      comparator,
-      direction,
-      earlyTerminate
+      direction
     );
     let count = 0;
     const intersection = filterValues && filterValues.size > 0 ? filterValues : null;
     for (const pair of generator) {
-      const [k, v2] = pair;
+      const [k, v] = pair;
       if (intersection && !intersection.has(k)) {
         continue;
       }
-      let isMatch = true;
-      for (const key in condition) {
-        if (key === driverKey) continue;
-        const verify = this.verifierMap[key];
-        const condValue = condition[key];
-        if (!verify(v2, condValue)) {
-          isMatch = false;
-          break;
-        }
-      }
-      if (isMatch) {
+      if (this.verify(v, condition)) {
         yield pair;
         count++;
         if (limit !== void 0 && count >= limit) {
@@ -3298,22 +3381,19 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
     }
     return node;
   }
-  async *getPairsGenerator(value, startNode, endNode, comparator, direction, earlyTerminate) {
+  async *getPairsGenerator(startNode, endNode, direction) {
     let node = startNode;
-    let done = false;
-    let hasMatched = false;
     let nextNodePromise = null;
-    while (!done) {
+    while (true) {
       if (endNode && node.id === endNode.id) {
-        done = true;
         break;
       }
       if (direction === 1) {
-        if (node.next && !done) {
+        if (node.next) {
           nextNodePromise = this.getNode(node.next);
         }
       } else {
-        if (node.prev && !done) {
+        if (node.prev) {
           nextNodePromise = this.getNode(node.prev);
         }
       }
@@ -3322,14 +3402,8 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
         for (let i = 0; i < len; i++) {
           const nValue = node.values[i];
           const keys = node.keys[i];
-          if (comparator(nValue, value)) {
-            hasMatched = true;
-            for (let j = 0; j < keys.length; j++) {
-              yield [keys[j], nValue];
-            }
-          } else if (earlyTerminate && hasMatched) {
-            done = true;
-            break;
+          for (let j = 0, kLen = keys.length; j < kLen; j++) {
+            yield [keys[j], nValue];
           }
         }
       } else {
@@ -3337,27 +3411,17 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
         while (i--) {
           const nValue = node.values[i];
           const keys = node.keys[i];
-          if (comparator(nValue, value)) {
-            hasMatched = true;
-            let j = keys.length;
-            while (j--) {
-              yield [keys[j], nValue];
-            }
-          } else if (earlyTerminate && hasMatched) {
-            done = true;
-            break;
+          let j = keys.length;
+          while (j--) {
+            yield [keys[j], nValue];
           }
         }
       }
-      if (done) {
-        if (nextNodePromise) await nextNodePromise;
-        break;
-      }
       if (nextNodePromise) {
         node = await nextNodePromise;
         nextNodePromise = null;
       } else {
-        done = true;
+        break;
       }
     }
   }
@@ -3445,49 +3509,36 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
   }
   async *whereStream(condition, options) {
     const { filterValues, limit, order = "asc" } = options ?? {};
-    const driverKey = this.getDriverKey(condition);
-    if (!driverKey) return;
-    const value = condition[driverKey];
-    const v = this.ensureValues(value);
-    const config = this.searchConfigs[driverKey][order];
-    let startNode = await config.start(this, v);
-    let endNode = await config.end(this, v);
-    const direction = config.direction;
-    const earlyTerminate = config.earlyTerminate;
-    if (order === "desc" && !startNode) {
-      startNode = await this.rightestNode();
-    }
-    if (order === "asc" && !startNode) {
-      startNode = await this.leftestNode();
+    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 comparator = this.verifierMap[driverKey];
     const generator = this.getPairsGenerator(
-      value,
       startNode,
       endNode,
-      comparator,
-      direction,
-      earlyTerminate
+      direction
     );
     let count = 0;
     const intersection = filterValues && filterValues.size > 0 ? filterValues : null;
     for await (const pair of generator) {
-      const [k, v2] = pair;
+      const [k, v] = pair;
       if (intersection && !intersection.has(k)) {
         continue;
       }
-      let isMatch = true;
-      for (const key in condition) {
-        if (key === driverKey) continue;
-        const verify = this.verifierMap[key];
-        const condValue = condition[key];
-        if (!verify(v2, condValue)) {
-          isMatch = false;
-          break;
-        }
-      }
-      if (isMatch) {
+      if (this.verify(v, condition)) {
         yield pair;
         count++;
         if (limit !== void 0 && count >= limit) {

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

@@ -86,13 +86,23 @@ export declare abstract class BPTreeTransaction<K, V> {
     protected _insertValueIntoLeaf(leaf: BPTreeLeafNode<K, V>, key: K, value: V): boolean;
     protected _cloneNode<T extends BPTreeUnknownNode<K, V>>(node: T): T;
     /**
-     * Selects the best driver key from a condition object.
-     * The driver key determines the starting point and traversal direction for queries.
+     * 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.
-     * @returns The best driver key or null if no valid key found.
-     */
-    protected getDriverKey(condition: BPTreeCondition<V>): keyof BPTreeCondition<V> | null;
+     * @param order The sort order ('asc' or 'desc').
+     * @returns The resolved start/end keys, values, and traversal direction.
+     */
+    resolveStartEndConfigs(condition: BPTreeCondition<V>, order: 'asc' | 'desc'): {
+        startKey: keyof BPTreeCondition<V> | null;
+        endKey: keyof BPTreeCondition<V> | null;
+        startValues: V[];
+        endValues: V[];
+        direction: 1 | -1;
+    };
+    private static readonly _lowerBoundKeys;
+    private static readonly _upperBoundKeys;
     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>>;

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

@@ -32,7 +32,7 @@ export declare class BPTreeAsyncTransaction<K, V> extends BPTreeTransaction<K, V
     protected insertableEndNode(value: V, direction: 1 | -1): Promise<BPTreeLeafNode<K, V> | null>;
     protected leftestNode(): Promise<BPTreeLeafNode<K, V>>;
     protected rightestNode(): Promise<BPTreeLeafNode<K, V>>;
-    protected getPairsGenerator(value: V, startNode: BPTreeLeafNode<K, V>, endNode: BPTreeLeafNode<K, V> | null, comparator: (nodeValue: V, value: V) => boolean, direction: 1 | -1, earlyTerminate: boolean): AsyncGenerator<[K, V]>;
+    protected getPairsGenerator(startNode: BPTreeLeafNode<K, V>, endNode: BPTreeLeafNode<K, V> | null, direction: 1 | -1): AsyncGenerator<[K, V]>;
     init(): Promise<void>;
     protected _initInternal(): Promise<void>;
     exists(key: K, value: V): Promise<boolean>;

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

@@ -29,7 +29,7 @@ export declare class BPTreeSyncTransaction<K, V> extends BPTreeTransaction<K, V>
     protected insertableEndNode(value: V, direction: 1 | -1): BPTreeLeafNode<K, V> | null;
     protected leftestNode(): BPTreeLeafNode<K, V>;
     protected rightestNode(): BPTreeLeafNode<K, V>;
-    protected getPairsGenerator(value: V, startNode: BPTreeLeafNode<K, V>, endNode: BPTreeLeafNode<K, V> | null, comparator: (nodeValue: V, value: V) => boolean, direction: 1 | -1, earlyTerminate: boolean): Generator<[K, V]>;
+    protected getPairsGenerator(startNode: BPTreeLeafNode<K, V>, endNode: BPTreeLeafNode<K, V> | null, direction: 1 | -1): Generator<[K, V]>;
     init(): void;
     protected _initInternal(): void;
     exists(key: K, value: V): boolean;

package/package.json

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