document-dataply 0.0.9-alpha.9 → 0.0.9

package/dist/cjs/index.js

@@ -157,39 +157,125 @@ var require_cjs = __commonJS({
     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;
+        }
+        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);
         }
-        this.cache.set(key, value);
-        return this;
       }
+      /**
+       * 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 {
@@ -1583,28 +1669,28 @@ var require_cjs = __commonJS({
       searchConfigs = {
         gt: {
           asc: {
-            start: (tx, v) => tx.insertableNodeByPrimary(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
           }
@@ -1612,12 +1698,12 @@ var require_cjs = __commonJS({
         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
@@ -1626,12 +1712,12 @@ var require_cjs = __commonJS({
         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
@@ -1639,14 +1725,14 @@ var require_cjs = __commonJS({
         },
         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
           }
@@ -1667,42 +1753,42 @@ var require_cjs = __commonJS({
         },
         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.insertableNodeByPrimary(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
           }
@@ -1710,12 +1796,12 @@ var require_cjs = __commonJS({
         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
@@ -1724,12 +1810,12 @@ var require_cjs = __commonJS({
         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
@@ -1737,14 +1823,14 @@ var require_cjs = __commonJS({
         },
         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.insertableRightestEndNodeByPrimary(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
           }
@@ -1765,14 +1851,14 @@ var require_cjs = __commonJS({
         },
         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.insertableRightestEndNodeByPrimary(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
           }
@@ -1928,30 +2014,69 @@ var require_cjs = __commonJS({
         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.
-       */
-      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;
-      }
+       * @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];
+          if (key in condition) {
+            startKey = key;
+            startValues = _BPTreeTransaction._multiValueKeys.includes(key) ? this.ensureValues(condition[key]) : [condition[key]];
+            break;
+          }
+        }
+        for (let i = 0, len = endCandidates.length; i < len; i++) {
+          const key = endCandidates[i];
+          if (key in condition) {
+            endKey = key;
+            endValues = _BPTreeTransaction._multiValueKeys.includes(key) ? this.ensureValues(condition[key]) : [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"
+      ];
+      // 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;
@@ -2188,7 +2313,7 @@ var require_cjs = __commonJS({
           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);
@@ -2196,7 +2321,7 @@ var require_cjs = __commonJS({
         }
         return node;
       }
-      insertableNodeByPrimary(value) {
+      findLowerBoundLeaf(value) {
         let node = this.getNode(this.rootId);
         while (!node.leaf) {
           const { index } = this._binarySearchValues(node.values, value, true, false);
@@ -2204,7 +2329,7 @@ var require_cjs = __commonJS({
         }
         return node;
       }
-      insertableRightestNodeByPrimary(value) {
+      findUpperBoundLeaf(value) {
         let node = this.getNode(this.rootId);
         while (!node.leaf) {
           const { index } = this._binarySearchValues(node.values, value, true, true);
@@ -2212,15 +2337,8 @@ var require_cjs = __commonJS({
         }
         return node;
       }
-      insertableRightestEndNodeByPrimary(value) {
-        const node = this.insertableRightestNodeByPrimary(value);
-        if (!node.next) {
-          return null;
-        }
-        return this.getNode(node.next);
-      }
-      insertableEndNode(value, direction) {
-        const insertableNode = this.insertableNode(value);
+      findOuterBoundaryLeaf(value, direction) {
+        const insertableNode = direction === -1 ? this.findLowerBoundLeaf(value) : this.findUpperBoundLeaf(value);
         let key;
         switch (direction) {
           case -1:
@@ -2257,13 +2375,10 @@ var require_cjs = __commonJS({
         }
         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;
@@ -2271,14 +2386,8 @@ var require_cjs = __commonJS({
             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 {
@@ -2286,30 +2395,17 @@ var require_cjs = __commonJS({
             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);
           }
         }
@@ -2354,7 +2450,7 @@ var require_cjs = __commonJS({
         }
       }
       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];
@@ -2398,49 +2494,36 @@ var require_cjs = __commonJS({
       }
       *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) {
@@ -2464,7 +2547,7 @@ var require_cjs = __commonJS({
         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(
@@ -2492,7 +2575,7 @@ var require_cjs = __commonJS({
         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) {
@@ -2734,7 +2817,7 @@ var require_cjs = __commonJS({
         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;
@@ -3316,7 +3399,7 @@ var require_cjs = __commonJS({
           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);
@@ -3324,7 +3407,7 @@ var require_cjs = __commonJS({
         }
         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);
@@ -3332,7 +3415,7 @@ var require_cjs = __commonJS({
         }
         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);
@@ -3340,15 +3423,8 @@ var require_cjs = __commonJS({
         }
         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 = await this.insertableNode(value);
+      async findOuterBoundaryLeaf(value, direction) {
+        const insertableNode = direction === -1 ? await this.findLowerBoundLeaf(value) : await this.findUpperBoundLeaf(value);
         let key;
         switch (direction) {
           case -1:
@@ -3385,22 +3461,19 @@ var require_cjs = __commonJS({
         }
         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);
             }
           }
@@ -3409,14 +3482,8 @@ var require_cjs = __commonJS({
             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 {
@@ -3424,27 +3491,17 @@ var require_cjs = __commonJS({
             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;
           }
         }
       }
@@ -3488,7 +3545,7 @@ var require_cjs = __commonJS({
         }
       }
       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];
@@ -3532,49 +3589,36 @@ var require_cjs = __commonJS({
       }
       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) {
@@ -3599,7 +3643,7 @@ var require_cjs = __commonJS({
       }
       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 +3673,7 @@ var require_cjs = __commonJS({
           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 +3917,7 @@ var require_cjs = __commonJS({
           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;
@@ -4869,39 +4913,125 @@ var require_cjs = __commonJS({
     var MVCCStrategy2 = class {
     };
     var LRUMap3 = 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;
+        }
+        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);
         }
-        this.cache.set(key, value);
-        return this;
       }
+      /**
+       * 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 MVCCTransaction2 = class {
@@ -6348,21 +6478,66 @@ var require_cjs = __commonJS({
       }
       return (crc ^ -1) >>> 0;
     }
-    function getMinMaxValue(array) {
-      let i = 0;
-      let min = Infinity;
-      let max = -Infinity;
-      let len = array.length;
-      while (i < len) {
-        if (array[i] < min) {
-          min = array[i];
-        }
-        if (array[i] > max) {
-          max = array[i];
+    function calcThreshold(sortedGaps, n) {
+      const gLen = sortedGaps.length;
+      if (gLen === 0) return 0;
+      const median = sortedGaps[Math.floor(gLen * 0.5)];
+      const q1 = sortedGaps[Math.floor(gLen * 0.25)];
+      const q3 = sortedGaps[Math.floor(gLen * 0.75)];
+      const iqr = q3 - q1;
+      const logN = Math.max(1, Math.log10(n));
+      if (iqr > 0) {
+        const threshold2 = q3 + iqr * 1.5 * logN;
+        const minJump = Math.max(median * 5, 20);
+        return Math.max(threshold2, minJump);
+      }
+      const baseGap = median > 0 ? median : 1;
+      const p90 = sortedGaps[Math.floor(gLen * 0.9)];
+      if (p90 > baseGap) {
+        const threshold2 = baseGap + (p90 - baseGap) * 0.5 * logN;
+        return Math.max(threshold2, baseGap * 5, 20);
+      }
+      let mean = 0;
+      for (let i = 0; i < gLen; i++) mean += sortedGaps[i];
+      mean /= gLen;
+      let variance = 0;
+      for (let i = 0; i < gLen; i++) {
+        const d = sortedGaps[i] - mean;
+        variance += d * d;
+      }
+      const stddev = Math.sqrt(variance / gLen);
+      if (stddev === 0) {
+        return baseGap * 2;
+      }
+      const threshold = mean + stddev * logN;
+      return Math.max(threshold, baseGap * 5, 20);
+    }
+    function clusterNumbers(numbers, maxGap) {
+      const n = numbers.length;
+      if (n === 0) return [];
+      if (n === 1) return [new Float64Array([numbers[0]])];
+      const sorted = (numbers instanceof Float64Array ? numbers.slice() : Float64Array.from(numbers)).sort();
+      const gaps = new Float64Array(n - 1);
+      for (let i = 0, len = n - 1; i < len; i++) {
+        gaps[i] = sorted[i + 1] - sorted[i];
+      }
+      const sortedGaps = gaps.slice().sort();
+      let threshold;
+      if (maxGap !== void 0) {
+        threshold = maxGap;
+      } else {
+        threshold = calcThreshold(sortedGaps, n);
+      }
+      const clusters = [];
+      let clusterStart = 0;
+      for (let i = 0, len = n - 1; i < len; i++) {
+        if (gaps[i] > threshold) {
+          clusters.push(sorted.subarray(clusterStart, i + 1));
+          clusterStart = i + 1;
         }
-        i++;
       }
-      return [min, max];
+      clusters.push(sorted.subarray(clusterStart));
+      return clusters;
     }
     var Row = class _Row {
       static CONSTANT = {
@@ -8180,9 +8355,6 @@ var require_cjs = __commonJS({
        */
       async write(pageId, data) {
         const pageStartPos = pageId * this.pageSize;
-        if (pageStartPos + this.pageSize > 512 * 1024 * 1024) {
-          throw new Error(`[Safety Limit] File write exceeds 512MB limit at position ${pageStartPos}`);
-        }
         const dataCopy = new Uint8Array(this.pageSize);
         dataCopy.set(data);
         this.dirtyPages.set(pageId, dataCopy);
@@ -8209,6 +8381,22 @@ var require_cjs = __commonJS({
           this.dirtyPages.delete(pageId);
         }
       }
+      /**
+       * 지정된 페이지들만 디스크에 기록합니다.
+       * WAL 없이 트랜잭션 커밋 시, 해당 트랜잭션의 dirty pages만 선택적으로 flush합니다.
+       * @param pages 기록할 페이지 맵 (PageID -> PageData)
+       */
+      async flushPages(pages) {
+        if (pages.size === 0) {
+          return;
+        }
+        const sortedPageIds = Array.from(pages.keys()).sort((a, b) => a - b);
+        for (const pageId of sortedPageIds) {
+          const data = pages.get(pageId);
+          const position = pageId * this.pageSize;
+          await this._writeToDisk(data, position);
+        }
+      }
       /**
        * 메인 DB 파일의 물리적 동기화를 수행합니다 (fsync).
        */
@@ -9289,17 +9477,40 @@ var require_cjs = __commonJS({
         for (let i = 0, len = pks.length; i < len; i++) {
           pkIndexMap.set(pks[i], i);
         }
-        const [minPk, maxPk] = getMinMaxValue(pks);
-        const pkRidPairs = new Array(pks.length).fill(null);
+        const validCount = pks.length;
+        const pkArray = new Float64Array(validCount).fill(0);
+        const ridArray = new Float64Array(validCount).fill(0);
+        const indexArray = new Float64Array(validCount).fill(0);
         const btx = await this.getBPTreeTransaction(tx);
-        const stream = btx.whereStream({ gte: minPk, lte: maxPk });
-        for await (const [rid, pk] of stream) {
-          const index = pkIndexMap.get(pk);
-          if (index !== void 0) {
-            pkRidPairs[index] = { pk, rid, index };
+        const clusters = clusterNumbers(pks, this.order / 2);
+        for (let i = 0, len = clusters.length; i < len; i++) {
+          const cluster = clusters[i];
+          const minPk = cluster[0];
+          const maxPk = cluster[cluster.length - 1];
+          if (minPk === maxPk) {
+            const keys = await btx.keys({ equal: minPk });
+            if (keys.size > 0) {
+              const rid = keys.values().next().value;
+              const index = pkIndexMap.get(minPk);
+              if (index !== void 0) {
+                pkArray[index] = minPk;
+                ridArray[index] = rid;
+                indexArray[index] = index;
+              }
+            }
+            continue;
+          }
+          const stream = btx.whereStream({ gte: minPk, lte: maxPk });
+          for await (const [rid, pk] of stream) {
+            const index = pkIndexMap.get(pk);
+            if (index !== void 0) {
+              pkArray[index] = pk;
+              ridArray[index] = rid;
+              indexArray[index] = index;
+            }
           }
         }
-        return this.fetchRowsByRids(pkRidPairs, tx);
+        return this.fetchRowsByRids(validCount, pkArray, ridArray, indexArray, tx);
       }
       /**
        * Fetches multiple rows by their RID and PK combinations, grouping by page ID to minimize I/O.
@@ -9307,19 +9518,21 @@ var require_cjs = __commonJS({
        * @param tx Transaction
        * @returns Array of row data in the same order as input PKs
        */
-      async fetchRowsByRids(pkRidPairs, tx) {
-        const result = new Array(pkRidPairs.length).fill(null);
-        if (pkRidPairs.length === 0) return result;
+      async fetchRowsByRids(validCount, pkArray, ridArray, indexArray, tx) {
+        const result = new Array(validCount).fill(null);
+        if (validCount === 0) return result;
         const pageGroupMap = /* @__PURE__ */ new Map();
-        for (const pair of pkRidPairs) {
-          if (pair === null) continue;
-          const rid = pair.rid;
+        for (let i = 0; i < validCount; i++) {
+          const pk = pkArray[i];
+          const rid = ridArray[i];
+          const index = indexArray[i];
+          if (pk === 0 && rid === 0 && index === 0) continue;
           const slotIndex = rid % 65536;
           const pageId = Math.floor(rid / 65536);
           if (!pageGroupMap.has(pageId)) {
             pageGroupMap.set(pageId, []);
           }
-          pageGroupMap.get(pageId).push({ pk: pair.pk, slotIndex, index: pair.index });
+          pageGroupMap.get(pageId).push({ pk, slotIndex, index });
         }
         const sortedPageIds = Array.from(pageGroupMap.keys()).sort((a, b) => a - b);
         await Promise.all(sortedPageIds.map(async (pageId) => {
@@ -9329,7 +9542,8 @@ var require_cjs = __commonJS({
             throw new Error(`Page ${pageId} is not a data page`);
           }
           const manager = this.factory.getManager(page);
-          for (const item of items) {
+          for (let i = 0, len = items.length; i < len; i++) {
+            const item = items[i];
             const row = manager.getRow(page, item.slotIndex);
             if (this.rowManager.getDeletedFlag(row)) {
               result[item.index] = null;
@@ -9566,7 +9780,9 @@ var require_cjs = __commonJS({
             for (const [pageId, data] of this.dirtyPages) {
               await this.pageStrategy.write(pageId, data);
             }
-            if (this.pfs.wal) {
+            if (!this.pfs.wal) {
+              await this.pfs.strategy.flushPages(this.dirtyPages);
+            } else {
               this.pfs.wal.incrementWrittenPages(this.dirtyPages.size);
               if (this.pfs.wal.shouldCheckpoint(this.pfs.options.walCheckpointThreshold)) {
                 shouldTriggerCheckpoint = true;
@@ -10286,61 +10502,36 @@ var DocumentSerializeStrategyAsync = class extends import_dataply.SerializeStrat
 
 // src/core/bptree/documentComparator.ts
 var import_dataply2 = __toESM(require_cjs());
-function comparePrimitive(a, b) {
-  if (a === b) return 0;
-  if (a === null) return -1;
-  if (b === null) return 1;
-  if (typeof a !== typeof b) {
-    const typeOrder = (v) => typeof v === "boolean" ? 0 : typeof v === "number" ? 1 : 2;
-    return typeOrder(a) - typeOrder(b);
-  }
-  if (typeof a === "string" && typeof b === "string") {
-    return a.localeCompare(b);
+function compareDiff(a, b) {
+  if (typeof a !== "string" && typeof b !== "string") {
+    return +a - +b;
   }
-  return +a - +b;
+  return (a + "").localeCompare(b + "");
 }
 function compareValue(a, b) {
   const aArr = Array.isArray(a);
   const bArr = Array.isArray(b);
   if (!aArr && !bArr) {
-    return comparePrimitive(a, b);
-  }
-  const aList = aArr ? a : [a];
-  const bList = bArr ? b : [b];
-  const len = Math.min(aList.length, bList.length);
-  for (let i = 0; i < len; i++) {
-    const diff = comparePrimitive(aList[i], bList[i]);
-    if (diff !== 0) return diff;
-  }
-  return aList.length - bList.length;
-}
-function comparePrimaryValue(a, b) {
-  const aArr = Array.isArray(a);
-  const bArr = Array.isArray(b);
-  if (!aArr && !bArr) {
-    return comparePrimitive(a, b);
+    return compareDiff(a, b);
   }
   const aList = aArr ? a : [a];
   const bList = bArr ? b : [b];
   const len = Math.min(aList.length, bList.length);
   for (let i = 0; i < len; i++) {
-    const diff = comparePrimitive(aList[i], bList[i]);
+    const diff = compareDiff(aList[i], bList[i]);
     if (diff !== 0) return diff;
   }
   return 0;
 }
 var DocumentValueComparator = class extends import_dataply2.ValueComparator {
   primaryAsc(a, b) {
-    return comparePrimaryValue(a.v, b.v);
+    return compareValue(a.v, b.v);
   }
   asc(a, b) {
     const diff = compareValue(a.v, b.v);
     return diff === 0 ? a.k - b.k : diff;
   }
   match(value) {
-    if (Array.isArray(value.v)) {
-      return value.v[0] + "";
-    }
     return value.v + "";
   }
 };
@@ -10583,8 +10774,7 @@ var DocumentDataplyAPI = class extends import_dataply3.DataplyAPI {
   async registerIndexRuntime(name, option, tx) {
     const config = this.toIndexMetaConfig(option);
     if (this.registeredIndices.has(name)) {
-      const existing = this.registeredIndices.get(name);
-      if (JSON.stringify(existing) === JSON.stringify(config)) return;
+      throw new Error(`Index "${name}" already exists.`);
     }
     await this.runWithDefaultWrite(async (tx2) => {
       const metadata = await this.getDocumentInnerMetadata(tx2);
@@ -10593,7 +10783,8 @@ var DocumentDataplyAPI = class extends import_dataply3.DataplyAPI {
       this.indices = metadata.indices;
       this.registeredIndices.set(name, config);
       const fields = this.getFieldsFromConfig(config);
-      for (const field of fields) {
+      for (let i = 0; i < fields.length; i++) {
+        const field = fields[i];
         this.indexedFields.add(field);
         if (!this.fieldToIndices.has(field)) {
           this.fieldToIndices.set(field, []);
@@ -10625,14 +10816,14 @@ var DocumentDataplyAPI = class extends import_dataply3.DataplyAPI {
    */
   async dropIndex(name, tx) {
     if (name === "_id") {
-      throw new Error("Cannot drop the _id index");
+      throw new Error('Cannot drop the "_id" index.');
     }
     if (!this._initialized) {
       this.pendingCreateIndices.delete(name);
       return;
     }
     if (!this.registeredIndices.has(name)) {
-      throw new Error(`Index '${name}' does not exist`);
+      throw new Error(`Index "${name}" does not exist.`);
     }
     await this.runWithDefaultWrite(async (tx2) => {
       const config = this.registeredIndices.get(name);
@@ -10642,7 +10833,8 @@ var DocumentDataplyAPI = class extends import_dataply3.DataplyAPI {
       this.indices = metadata.indices;
       this.registeredIndices.delete(name);
       const fields = this.getFieldsFromConfig(config);
-      for (const field of fields) {
+      for (let i = 0; i < fields.length; i++) {
+        const field = fields[i];
         const indexNames = this.fieldToIndices.get(field);
         if (indexNames) {
           const filtered = indexNames.filter((n) => n !== name);
@@ -10673,7 +10865,7 @@ var DocumentDataplyAPI = class extends import_dataply3.DataplyAPI {
       if (!Array.isArray(option.fields) || option.fields.length === 0) {
         throw new Error('btree index requires a non-empty "fields" array');
       }
-      for (let i = 0; i < option.fields.length; i++) {
+      for (let i = 0, len = option.fields.length; i < len; i++) {
         if (typeof option.fields[i] !== "string" || option.fields[i].length === 0) {
           throw new Error(`btree index "fields[${i}]" must be a non-empty string, got: ${JSON.stringify(option.fields[i])}`);
         }
@@ -10806,7 +10998,8 @@ var DocumentDataplyAPI = class extends import_dataply3.DataplyAPI {
         const doc = await this.getDocument(k, tx2);
         if (!doc) continue;
         const flatDoc = this.flattenDocument(doc);
-        for (const indexName of backfillTargets) {
+        for (let i = 0, len = backfillTargets.length; i < len; i++) {
+          const indexName = backfillTargets[i];
           if (!(indexName in indexTxMap)) continue;
           const config = this.registeredIndices.get(indexName);
           if (!config) continue;
@@ -10818,8 +11011,8 @@ var DocumentDataplyAPI = class extends import_dataply3.DataplyAPI {
             const ftsConfig = this.getFtsConfig(config);
             const tokens = ftsConfig ? tokenize(v, ftsConfig) : [v];
             const batchInsertData = [];
-            for (let i = 0, len = tokens.length; i < len; i++) {
-              const token = tokens[i];
+            for (let i2 = 0, len2 = tokens.length; i2 < len2; i2++) {
+              const token = tokens[i2];
               const keyToInsert = this.getTokenKey(k, token);
               const entry = { k, v: token };
               batchInsertData.push([keyToInsert, entry]);
@@ -11003,6 +11196,191 @@ var DocumentDataplyAPI = class extends import_dataply3.DataplyAPI {
     }
     return result;
   }
+  /**
+   * B-Tree 타입 인덱스의 선택도를 평가하고 트리에 부여할 조건을 산출합니다.
+   * 필드 매칭 여부를 검사하고, 연속된(Prefix) 조건에 대해 점수를 부여하며 Start/End 바운드를 구성합니다.
+   * 
+   * @param indexName 평가할 인덱스의 이름 (예: idx_nickname_createdat)
+   * @param config 등록된 인덱스의 설정 객체
+   * @param query 쿼리 객체
+   * @param queryFields 쿼리에 포함된 필드 목록 집합
+   * @param treeTx 조회를 수행할 B-Tree 트랜잭션 객체
+   * @param orderByField 정렬에 사용할 필드명 (옵션)
+   * @returns B-Tree 인덱스 후보 정보 (조건, 점수, 커버된 필드 등), 적합하지 않으면 null
+   */
+  evaluateBTreeCandidate(indexName, config, query, queryFields, treeTx, orderByField) {
+    const primaryField = config.fields[0];
+    if (!queryFields.has(primaryField)) return null;
+    const builtCondition = {};
+    let score = 0;
+    let isConsecutive = true;
+    const coveredFields = [];
+    const compositeVerifyFields = [];
+    const startValues = [];
+    const endValues = [];
+    let startOperator = null;
+    let endOperator = null;
+    for (let i = 0, len = config.fields.length; i < len; i++) {
+      const field = config.fields[i];
+      if (!queryFields.has(field)) {
+        isConsecutive = false;
+        continue;
+      }
+      coveredFields.push(field);
+      score += 1;
+      if (isConsecutive) {
+        const cond = query[field];
+        if (cond !== void 0) {
+          let isBounded = false;
+          if (typeof cond !== "object" || cond === null) {
+            score += 100;
+            startValues.push(cond);
+            endValues.push(cond);
+            startOperator = "primaryGte";
+            endOperator = "primaryLte";
+            isBounded = true;
+          } else if ("primaryEqual" in cond || "equal" in cond) {
+            const val = cond.primaryEqual?.v ?? cond.equal?.v ?? cond.primaryEqual ?? cond.equal;
+            score += 100;
+            startValues.push(val);
+            endValues.push(val);
+            startOperator = "primaryGte";
+            endOperator = "primaryLte";
+            isBounded = true;
+          } else if ("primaryGte" in cond || "gte" in cond) {
+            const val = cond.primaryGte?.v ?? cond.gte?.v ?? cond.primaryGte ?? cond.gte;
+            score += 50;
+            isConsecutive = false;
+            startValues.push(val);
+            startOperator = "primaryGte";
+            if (endValues.length > 0) endOperator = "primaryLte";
+            isBounded = true;
+          } else if ("primaryGt" in cond || "gt" in cond) {
+            const val = cond.primaryGt?.v ?? cond.gt?.v ?? cond.primaryGt ?? cond.gt;
+            score += 50;
+            isConsecutive = false;
+            startValues.push(val);
+            startOperator = "primaryGt";
+            if (endValues.length > 0) endOperator = "primaryLte";
+            isBounded = true;
+          } else if ("primaryLte" in cond || "lte" in cond) {
+            const val = cond.primaryLte?.v ?? cond.lte?.v ?? cond.primaryLte ?? cond.lte;
+            score += 50;
+            isConsecutive = false;
+            endValues.push(val);
+            endOperator = "primaryLte";
+            if (startValues.length > 0) startOperator = "primaryGte";
+            isBounded = true;
+          } else if ("primaryLt" in cond || "lt" in cond) {
+            const val = cond.primaryLt?.v ?? cond.lt?.v ?? cond.primaryLt ?? cond.lt;
+            score += 50;
+            isConsecutive = false;
+            endValues.push(val);
+            endOperator = "primaryLt";
+            if (startValues.length > 0) startOperator = "primaryGte";
+            isBounded = true;
+          } else if ("primaryOr" in cond || "or" in cond) {
+            score += 20;
+            isConsecutive = false;
+          } else if ("like" in cond) {
+            score += 15;
+            isConsecutive = false;
+          } else {
+            score += 10;
+            isConsecutive = false;
+          }
+          if (!isBounded && field !== primaryField) {
+            compositeVerifyFields.push(field);
+          }
+        }
+      } else {
+        if (field !== primaryField) {
+          compositeVerifyFields.push(field);
+        }
+      }
+    }
+    if (coveredFields.length === 1 && config.fields.length === 1) {
+      Object.assign(builtCondition, query[primaryField]);
+    } else {
+      if (startOperator && startValues.length > 0) {
+        builtCondition[startOperator] = { v: startValues.length === 1 ? startValues[0] : startValues };
+      }
+      if (endOperator && endValues.length > 0) {
+        if (startOperator && startValues.length === endValues.length && startValues.every((val, i) => val === endValues[i])) {
+          delete builtCondition[startOperator];
+          builtCondition["primaryEqual"] = { v: startValues.length === 1 ? startValues[0] : startValues };
+        } else {
+          builtCondition[endOperator] = { v: endValues.length === 1 ? endValues[0] : endValues };
+        }
+      }
+      if (Object.keys(builtCondition).length === 0) {
+        Object.assign(builtCondition, query[primaryField] || {});
+      }
+    }
+    let isIndexOrderSupported = false;
+    if (orderByField) {
+      for (let i = 0, len = config.fields.length; i < len; i++) {
+        const field = config.fields[i];
+        if (field === orderByField) {
+          isIndexOrderSupported = true;
+          break;
+        }
+        const cond = query[field];
+        let isExactMatch = false;
+        if (cond !== void 0) {
+          if (typeof cond !== "object" || cond === null) isExactMatch = true;
+          else if ("primaryEqual" in cond || "equal" in cond) isExactMatch = true;
+        }
+        if (!isExactMatch) break;
+      }
+      if (isIndexOrderSupported) {
+        score += 200;
+      }
+    }
+    return {
+      tree: treeTx,
+      condition: builtCondition,
+      field: primaryField,
+      indexName,
+      isFtsMatch: false,
+      score,
+      compositeVerifyFields,
+      coveredFields,
+      isIndexOrderSupported
+    };
+  }
+  /**
+   * FTS (Full Text Search) 타입 인덱스의 선택도를 평가합니다.
+   * 'match' 연산자가 쿼리에 존재하는지 확인하고, 검색용 토큰으로 분해(tokenize)하여 점수를 매깁니다.
+   * 
+   * @param indexName 평가할 인덱스의 이름
+   * @param config 등록된 인덱스의 설정 객체
+   * @param query 쿼리 객체
+   * @param queryFields 쿼리에 포함된 필드 목록 집합
+   * @param treeTx 조회를 수행할 B-Tree 트랜잭션 객체
+   * @returns FTS 인덱스 후보 정보 (조건, 점수, 분석된 토큰 등), 적합하지 않으면 null
+   */
+  evaluateFTSCandidate(indexName, config, query, queryFields, treeTx) {
+    const field = config.fields;
+    if (!queryFields.has(field)) return null;
+    const condition = query[field];
+    if (!condition || typeof condition !== "object" || !("match" in condition)) return null;
+    const ftsConfig = this.getFtsConfig(config);
+    const matchTokens = ftsConfig ? tokenize(condition.match, ftsConfig) : [];
+    return {
+      tree: treeTx,
+      condition,
+      field,
+      indexName,
+      isFtsMatch: true,
+      matchTokens,
+      score: 90,
+      // FTS 쿼리는 기본적인 B-Tree 단일 검색(대략 101점)보다는 우선순위를 조금 낮게 가져가도록 90점 부여
+      compositeVerifyFields: [],
+      coveredFields: [field],
+      isIndexOrderSupported: false
+    };
+  }
   /**
    * Choose the best index (driver) for the given query.
    * Scores each index based on field coverage and condition type.
@@ -11018,95 +11396,26 @@ var DocumentDataplyAPI = class extends import_dataply3.DataplyAPI {
       const tree = this.trees.get(indexName);
       if (!tree) continue;
       if (config.type === "btree") {
-        const primaryField = config.fields[0];
-        if (!queryFields.has(primaryField)) continue;
-        const condition = query[primaryField];
         const treeTx = await tree.createTransaction();
-        let score = 0;
-        let isConsecutive = true;
-        const coveredFields = [];
-        const compositeVerifyFields = [];
-        for (const field of config.fields) {
-          if (!queryFields.has(field)) {
-            isConsecutive = false;
-            continue;
-          }
-          coveredFields.push(field);
-          if (field !== primaryField) {
-            compositeVerifyFields.push(field);
-          }
-          score += 1;
-          if (isConsecutive) {
-            const cond = query[field];
-            if (cond !== void 0) {
-              if (typeof cond !== "object" || cond === null) {
-                score += 100;
-              } else if ("primaryEqual" in cond || "equal" in cond) {
-                score += 100;
-              } else if ("primaryGte" in cond || "primaryLte" in cond || "primaryGt" in cond || "primaryLt" in cond || "gte" in cond || "lte" in cond || "gt" in cond || "lt" in cond) {
-                score += 50;
-                isConsecutive = false;
-              } else if ("primaryOr" in cond || "or" in cond) {
-                score += 20;
-                isConsecutive = false;
-              } else if ("like" in cond) {
-                score += 15;
-                isConsecutive = false;
-              } else {
-                score += 10;
-                isConsecutive = false;
-              }
-            }
-          }
-        }
-        let isIndexOrderSupported = false;
-        if (orderByField) {
-          for (const field of config.fields) {
-            if (field === orderByField) {
-              isIndexOrderSupported = true;
-              break;
-            }
-            const cond = query[field];
-            let isExactMatch = false;
-            if (cond !== void 0) {
-              if (typeof cond !== "object" || cond === null) isExactMatch = true;
-              else if ("primaryEqual" in cond || "equal" in cond) isExactMatch = true;
-            }
-            if (!isExactMatch) break;
-          }
-          if (isIndexOrderSupported) {
-            score += 200;
-          }
-        }
-        candidates.push({
-          tree: treeTx,
-          condition,
-          field: primaryField,
+        const candidate = this.evaluateBTreeCandidate(
           indexName,
-          isFtsMatch: false,
-          score,
-          compositeVerifyFields,
-          isIndexOrderSupported
-        });
+          config,
+          query,
+          queryFields,
+          treeTx,
+          orderByField
+        );
+        if (candidate) candidates.push(candidate);
       } else if (config.type === "fts") {
-        const field = config.fields;
-        if (!queryFields.has(field)) continue;
-        const condition = query[field];
-        if (!condition || typeof condition !== "object" || !("match" in condition)) continue;
         const treeTx = await tree.createTransaction();
-        const ftsConfig = this.getFtsConfig(config);
-        const matchTokens = ftsConfig ? tokenize(condition.match, ftsConfig) : [];
-        candidates.push({
-          tree: treeTx,
-          condition,
-          field,
+        const candidate = this.evaluateFTSCandidate(
           indexName,
-          isFtsMatch: true,
-          matchTokens,
-          score: 90,
-          compositeVerifyFields: [],
-          isIndexOrderSupported: false
-        });
+          config,
+          query,
+          queryFields,
+          treeTx
+        );
+        if (candidate) candidates.push(candidate);
       }
     }
     const rollback = () => {
@@ -11118,11 +11427,20 @@ var DocumentDataplyAPI = class extends import_dataply3.DataplyAPI {
       rollback();
       return null;
     }
-    candidates.sort((a, b) => b.score - a.score);
+    candidates.sort((a, b) => {
+      if (b.score !== a.score) return b.score - a.score;
+      const aConfig = this.registeredIndices.get(a.indexName);
+      const bConfig = this.registeredIndices.get(b.indexName);
+      const aFieldCount = aConfig ? Array.isArray(aConfig.fields) ? aConfig.fields.length : 1 : 0;
+      const bFieldCount = bConfig ? Array.isArray(bConfig.fields) ? bConfig.fields.length : 1 : 0;
+      return aFieldCount - bFieldCount;
+    });
     const driver = candidates[0];
-    const others = candidates.slice(1);
+    const driverCoveredFields = new Set(driver.coveredFields);
+    const others = candidates.slice(1).filter((c) => !driverCoveredFields.has(c.field));
     const compositeVerifyConditions = [];
-    for (const field of driver.compositeVerifyFields) {
+    for (let i = 0, len = driver.compositeVerifyFields.length; i < len; i++) {
+      const field = driver.compositeVerifyFields[i];
       if (query[field]) {
         compositeVerifyConditions.push({ field, condition: query[field] });
       }
@@ -11592,10 +11910,15 @@ var DocumentDataplyAPI = class extends import_dataply3.DataplyAPI {
    * Prefetch 방식으로 키 스트림을 청크 단위로 조회하여 문서를 순회합니다.
    * FTS 검증, 복합 인덱스 검증, others 후보에 대한 tree.verify() 검증을 통과한 문서만 yield 합니다.
    */
-  async *processChunkedKeysWithVerify(keysStream, startIdx, initialChunkSize, ftsConditions, compositeVerifyConditions, others, tx) {
+  async *processChunkedKeysWithVerify(keysStream, startIdx, initialChunkSize, limit, ftsConditions, compositeVerifyConditions, others, tx) {
     const verifyOthers = others.filter((o) => !o.isFtsMatch);
-    let currentChunkSize = initialChunkSize;
+    const isFts = ftsConditions.length > 0;
+    const isCompositeVerify = compositeVerifyConditions.length > 0;
+    const isVerifyOthers = verifyOthers.length > 0;
+    const isInfiniteLimit = isFinite(limit);
+    let currentChunkSize = isInfiniteLimit ? initialChunkSize : limit;
     let chunk = [];
+    let chunkSize = 0;
     let dropped = 0;
     const processChunk = async (pks) => {
       const docs = [];
@@ -11606,9 +11929,9 @@ var DocumentDataplyAPI = class extends import_dataply3.DataplyAPI {
         if (!s) continue;
         const doc = JSON.parse(s);
         chunkTotalSize += s.length * 2;
-        if (ftsConditions.length > 0 && !this.verifyFts(doc, ftsConditions)) continue;
-        if (compositeVerifyConditions.length > 0 && this.verifyCompositeConditions(doc, compositeVerifyConditions) === false) continue;
-        if (verifyOthers.length > 0) {
+        if (isFts && !this.verifyFts(doc, ftsConditions)) continue;
+        if (isCompositeVerify && this.verifyCompositeConditions(doc, compositeVerifyConditions) === false) continue;
+        if (isVerifyOthers) {
           const flatDoc = this.flattenDocument(doc);
           let passed = true;
           for (let k = 0, kLen = verifyOthers.length; k < kLen; k++) {
@@ -11628,7 +11951,9 @@ var DocumentDataplyAPI = class extends import_dataply3.DataplyAPI {
         }
         docs.push(doc);
       }
-      currentChunkSize = this.adjustChunkSize(currentChunkSize, chunkTotalSize);
+      if (isInfiniteLimit) {
+        currentChunkSize = this.adjustChunkSize(currentChunkSize, chunkTotalSize);
+      }
       return docs;
     };
     for await (const pk of keysStream) {
@@ -11637,15 +11962,17 @@ var DocumentDataplyAPI = class extends import_dataply3.DataplyAPI {
         continue;
       }
       chunk.push(pk);
-      if (chunk.length >= currentChunkSize) {
+      chunkSize++;
+      if (chunkSize >= currentChunkSize) {
         const docs = await processChunk(chunk);
-        for (let j = 0; j < docs.length; j++) yield docs[j];
+        for (let j = 0, dLen = docs.length; j < dLen; j++) yield docs[j];
         chunk = [];
+        chunkSize = 0;
       }
     }
-    if (chunk.length > 0) {
+    if (chunkSize > 0) {
       const docs = await processChunk(chunk);
-      for (let j = 0; j < docs.length; j++) yield docs[j];
+      for (let j = 0, dLen = docs.length; j < dLen; j++) yield docs[j];
     }
   }
   /**
@@ -11694,6 +12021,7 @@ var DocumentDataplyAPI = class extends import_dataply3.DataplyAPI {
       const driverResult = await self.getDriverKeys(query, orderByField, sortOrder);
       if (!driverResult) return;
       const { keysStream, others, compositeVerifyConditions, isDriverOrderByField, rollback } = driverResult;
+      const initialChunkSize = self.options.pageSize;
       try {
         if (!isDriverOrderByField && orderByField) {
           const topK = limit === Infinity ? Infinity : offset + limit;
@@ -11710,7 +12038,8 @@ var DocumentDataplyAPI = class extends import_dataply3.DataplyAPI {
           for await (const doc of self.processChunkedKeysWithVerify(
             keysStream,
             0,
-            self.options.pageSize,
+            initialChunkSize,
+            Infinity,
             ftsConditions,
             compositeVerifyConditions,
             others,
@@ -11751,7 +12080,8 @@ var DocumentDataplyAPI = class extends import_dataply3.DataplyAPI {
           for await (const doc of self.processChunkedKeysWithVerify(
             keysStream,
             startIdx,
-            self.options.pageSize,
+            initialChunkSize,
+            limit,
             ftsConditions,
             compositeVerifyConditions,
             others,