serializable-bptree 8.1.6 → 8.2.0

package/README.md

@@ -7,7 +7,7 @@
 This is a B+tree that's totally okay with duplicate values. If you need to keep track of the B+ tree's state, don't just leave it in memory - make sure you write it down.
 
 ```typescript
-import { readFileSync, writeFileSync, unlinkSync, existsSync } from 'fs'
+import { readFileSync, writeFileSync, unlinkSync, existsSync } from 'node:fs'
 import {
   BPTreeSync,
   SerializeStrategySync,
@@ -91,6 +91,8 @@ Additionally, this library supports asynchronous operations and rule-based query
 
 ```bash
 npm i serializable-bptree
+# or
+npx jsr add @izure/serializable-bptree
 ```
 
 ```typescript
@@ -156,7 +158,7 @@ const others = candidates.filter((c) => driver.tree !== c.tree)
 // 2. Execute query using the selected driver
 let keys = driver.tree.keys(driver.condition)
 for (const { tree, condition } of others) {
-  keys = tree.keys(condition, keys)
+  keys = tree.keys(condition, { filterValues: keys })
 }
 
 console.log('Found: ', keys)

package/dist/cjs/index.cjs

@@ -343,6 +343,30 @@ var MVCCTransaction = class {
       deleted
     };
   }
+  /**
+   * Checks for conflicts among multiple transactions.
+   * A conflict occurs if two or more transactions modify (write or delete) the same key.
+   * @param transactions Array of transactions to check.
+   * @returns An array of keys that are in conflict.
+   */
+  static CheckConflicts(transactions) {
+    const modifiedKeys = /* @__PURE__ */ new Map();
+    const conflicts = /* @__PURE__ */ new Set();
+    for (const tx of transactions) {
+      const txModified = /* @__PURE__ */ new Set([
+        ...tx.writeBuffer.keys(),
+        ...tx.deleteBuffer
+      ]);
+      for (const key of txModified) {
+        const count = modifiedKeys.get(key) ?? 0;
+        if (count > 0) {
+          conflicts.add(key);
+        }
+        modifiedKeys.set(key, count + 1);
+      }
+    }
+    return Array.from(conflicts);
+  }
   /**
    * Cleans up both deletedCache and versionIndex based on minActiveVersion.
    * Root transactions call this after commit to reclaim memory.
@@ -1632,6 +1656,15 @@ var BPTreeTransaction = class _BPTreeTransaction {
     }
     return best;
   }
+  /**
+   * Checks for conflicts between multiple transactions.
+   * 
+   * @param transactions Array of BPTreeTransaction instances to check
+   * @returns An array of keys that are in conflict. Empty array if no conflicts.
+   */
+  static CheckConflicts(transactions) {
+    return MVCCTransaction.CheckConflicts(transactions.map((tx) => tx.mvcc));
+  }
   /**
    * Returns the ID of the root node.
    * @returns The root node ID.
@@ -2084,11 +2117,7 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
         const { root, order } = head;
         this.strategy.head = head;
         this.order = order;
-        this._writeHead({
-          root,
-          order: this.order,
-          data: this.strategy.head.data
-        });
+        this.rootId = root;
       }
       if (this.order < 3) {
         throw new Error(`The 'order' parameter must be greater than 2. but got a '${this.order}'.`);
@@ -2125,17 +2154,24 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
     }
     return void 0;
   }
-  *keysStream(condition, filterValues, limit, order = "asc") {
-    const stream = this.whereStream(condition, limit, order);
+  *keysStream(condition, options) {
+    const { filterValues, limit, order = "asc" } = options ?? {};
+    const stream = this.whereStream(condition, options);
     const intersection = filterValues && filterValues.size > 0 ? filterValues : null;
+    let count = 0;
     for (const [key] of stream) {
       if (intersection && !intersection.has(key)) {
         continue;
       }
       yield key;
+      count++;
+      if (limit !== void 0 && count >= limit) {
+        break;
+      }
     }
   }
-  *whereStream(condition, limit, order = "asc") {
+  *whereStream(condition, options) {
+    const { filterValues, limit, order = "asc" } = options ?? {};
     const driverKey = this.getDriverKey(condition);
     if (!driverKey) return;
     const value = condition[driverKey];
@@ -2158,8 +2194,12 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
       earlyTerminate
     );
     let count = 0;
+    const intersection = filterValues && filterValues.size > 0 ? filterValues : null;
     for (const pair of generator) {
       const [k, v] = pair;
+      if (intersection && !intersection.has(k)) {
+        continue;
+      }
       let isMatch = true;
       for (const key in condition) {
         if (key === driverKey) continue;
@@ -2179,16 +2219,16 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
       }
     }
   }
-  keys(condition, filterValues, order = "asc") {
+  keys(condition, options) {
     const set = /* @__PURE__ */ new Set();
-    for (const key of this.keysStream(condition, filterValues, void 0, order)) {
+    for (const key of this.keysStream(condition, options)) {
       set.add(key);
     }
     return set;
   }
-  where(condition, order = "asc") {
+  where(condition, options) {
     const map = /* @__PURE__ */ new Map();
-    for (const [key, value] of this.whereStream(condition, void 0, order)) {
+    for (const [key, value] of this.whereStream(condition, options)) {
       map.set(key, value);
     }
     return map;
@@ -2414,6 +2454,12 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
     return node;
   }
   delete(key, value) {
+    if (value === void 0) {
+      value = this.get(key);
+    }
+    if (value === void 0) {
+      return;
+    }
     let node = this.insertableNodeByPrimary(value);
     let found = false;
     while (true) {
@@ -2865,14 +2911,6 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
       next,
       prev
     };
-    const head = await this._readHead();
-    if (head) {
-      await this._writeHead({
-        root: head.root,
-        order: head.order,
-        data: this.strategy.head.data
-      });
-    }
     await this.mvcc.create(id, node);
     return node;
   }
@@ -3165,11 +3203,7 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
         const { root, order } = head;
         this.strategy.head = head;
         this.order = order;
-        await this._writeHead({
-          root,
-          order: this.order,
-          data: this.strategy.head.data
-        });
+        this.rootId = root;
       }
       if (this.order < 3) {
         throw new Error(`The 'order' parameter must be greater than 2. but got a '${this.order}'.`);
@@ -3206,17 +3240,24 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
     }
     return void 0;
   }
-  async *keysStream(condition, filterValues, limit, order = "asc") {
-    const stream = this.whereStream(condition, limit, order);
+  async *keysStream(condition, options) {
+    const { filterValues, limit, order = "asc" } = options ?? {};
+    const stream = this.whereStream(condition, options);
     const intersection = filterValues && filterValues.size > 0 ? filterValues : null;
+    let count = 0;
     for await (const [key] of stream) {
       if (intersection && !intersection.has(key)) {
         continue;
       }
       yield key;
+      count++;
+      if (limit !== void 0 && count >= limit) {
+        break;
+      }
     }
   }
-  async *whereStream(condition, limit, order = "asc") {
+  async *whereStream(condition, options) {
+    const { filterValues, limit, order = "asc" } = options ?? {};
     const driverKey = this.getDriverKey(condition);
     if (!driverKey) return;
     const value = condition[driverKey];
@@ -3239,8 +3280,12 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
       earlyTerminate
     );
     let count = 0;
+    const intersection = filterValues && filterValues.size > 0 ? filterValues : null;
     for await (const pair of generator) {
       const [k, v] = pair;
+      if (intersection && !intersection.has(k)) {
+        continue;
+      }
       let isMatch = true;
       for (const key in condition) {
         if (key === driverKey) continue;
@@ -3260,16 +3305,16 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
       }
     }
   }
-  async keys(condition, filterValues, order = "asc") {
+  async keys(condition, options) {
     const set = /* @__PURE__ */ new Set();
-    for await (const key of this.keysStream(condition, filterValues, void 0, order)) {
+    for await (const key of this.keysStream(condition, options)) {
       set.add(key);
     }
     return set;
   }
-  async where(condition, order = "asc") {
+  async where(condition, options) {
     const map = /* @__PURE__ */ new Map();
-    for await (const [key, value] of this.whereStream(condition, void 0, order)) {
+    for await (const [key, value] of this.whereStream(condition, options)) {
       map.set(key, value);
     }
     return map;
@@ -3498,6 +3543,12 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
   }
   async delete(key, value) {
     return this.writeLock(0, async () => {
+      if (value === void 0) {
+        value = await this.get(key);
+      }
+      if (value === void 0) {
+        return;
+      }
       let node = await this.insertableNodeByPrimary(value);
       let found = false;
       while (true) {

package/dist/esm/index.mjs

@@ -307,6 +307,30 @@ var MVCCTransaction = class {
       deleted
     };
   }
+  /**
+   * Checks for conflicts among multiple transactions.
+   * A conflict occurs if two or more transactions modify (write or delete) the same key.
+   * @param transactions Array of transactions to check.
+   * @returns An array of keys that are in conflict.
+   */
+  static CheckConflicts(transactions) {
+    const modifiedKeys = /* @__PURE__ */ new Map();
+    const conflicts = /* @__PURE__ */ new Set();
+    for (const tx of transactions) {
+      const txModified = /* @__PURE__ */ new Set([
+        ...tx.writeBuffer.keys(),
+        ...tx.deleteBuffer
+      ]);
+      for (const key of txModified) {
+        const count = modifiedKeys.get(key) ?? 0;
+        if (count > 0) {
+          conflicts.add(key);
+        }
+        modifiedKeys.set(key, count + 1);
+      }
+    }
+    return Array.from(conflicts);
+  }
   /**
    * Cleans up both deletedCache and versionIndex based on minActiveVersion.
    * Root transactions call this after commit to reclaim memory.
@@ -1596,6 +1620,15 @@ var BPTreeTransaction = class _BPTreeTransaction {
     }
     return best;
   }
+  /**
+   * Checks for conflicts between multiple transactions.
+   * 
+   * @param transactions Array of BPTreeTransaction instances to check
+   * @returns An array of keys that are in conflict. Empty array if no conflicts.
+   */
+  static CheckConflicts(transactions) {
+    return MVCCTransaction.CheckConflicts(transactions.map((tx) => tx.mvcc));
+  }
   /**
    * Returns the ID of the root node.
    * @returns The root node ID.
@@ -2048,11 +2081,7 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
         const { root, order } = head;
         this.strategy.head = head;
         this.order = order;
-        this._writeHead({
-          root,
-          order: this.order,
-          data: this.strategy.head.data
-        });
+        this.rootId = root;
       }
       if (this.order < 3) {
         throw new Error(`The 'order' parameter must be greater than 2. but got a '${this.order}'.`);
@@ -2089,17 +2118,24 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
     }
     return void 0;
   }
-  *keysStream(condition, filterValues, limit, order = "asc") {
-    const stream = this.whereStream(condition, limit, order);
+  *keysStream(condition, options) {
+    const { filterValues, limit, order = "asc" } = options ?? {};
+    const stream = this.whereStream(condition, options);
     const intersection = filterValues && filterValues.size > 0 ? filterValues : null;
+    let count = 0;
     for (const [key] of stream) {
       if (intersection && !intersection.has(key)) {
         continue;
       }
       yield key;
+      count++;
+      if (limit !== void 0 && count >= limit) {
+        break;
+      }
     }
   }
-  *whereStream(condition, limit, order = "asc") {
+  *whereStream(condition, options) {
+    const { filterValues, limit, order = "asc" } = options ?? {};
     const driverKey = this.getDriverKey(condition);
     if (!driverKey) return;
     const value = condition[driverKey];
@@ -2122,8 +2158,12 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
       earlyTerminate
     );
     let count = 0;
+    const intersection = filterValues && filterValues.size > 0 ? filterValues : null;
     for (const pair of generator) {
       const [k, v] = pair;
+      if (intersection && !intersection.has(k)) {
+        continue;
+      }
       let isMatch = true;
       for (const key in condition) {
         if (key === driverKey) continue;
@@ -2143,16 +2183,16 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
       }
     }
   }
-  keys(condition, filterValues, order = "asc") {
+  keys(condition, options) {
     const set = /* @__PURE__ */ new Set();
-    for (const key of this.keysStream(condition, filterValues, void 0, order)) {
+    for (const key of this.keysStream(condition, options)) {
       set.add(key);
     }
     return set;
   }
-  where(condition, order = "asc") {
+  where(condition, options) {
     const map = /* @__PURE__ */ new Map();
-    for (const [key, value] of this.whereStream(condition, void 0, order)) {
+    for (const [key, value] of this.whereStream(condition, options)) {
       map.set(key, value);
     }
     return map;
@@ -2378,6 +2418,12 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
     return node;
   }
   delete(key, value) {
+    if (value === void 0) {
+      value = this.get(key);
+    }
+    if (value === void 0) {
+      return;
+    }
     let node = this.insertableNodeByPrimary(value);
     let found = false;
     while (true) {
@@ -2829,14 +2875,6 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
       next,
       prev
     };
-    const head = await this._readHead();
-    if (head) {
-      await this._writeHead({
-        root: head.root,
-        order: head.order,
-        data: this.strategy.head.data
-      });
-    }
     await this.mvcc.create(id, node);
     return node;
   }
@@ -3129,11 +3167,7 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
         const { root, order } = head;
         this.strategy.head = head;
         this.order = order;
-        await this._writeHead({
-          root,
-          order: this.order,
-          data: this.strategy.head.data
-        });
+        this.rootId = root;
       }
       if (this.order < 3) {
         throw new Error(`The 'order' parameter must be greater than 2. but got a '${this.order}'.`);
@@ -3170,17 +3204,24 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
     }
     return void 0;
   }
-  async *keysStream(condition, filterValues, limit, order = "asc") {
-    const stream = this.whereStream(condition, limit, order);
+  async *keysStream(condition, options) {
+    const { filterValues, limit, order = "asc" } = options ?? {};
+    const stream = this.whereStream(condition, options);
     const intersection = filterValues && filterValues.size > 0 ? filterValues : null;
+    let count = 0;
     for await (const [key] of stream) {
       if (intersection && !intersection.has(key)) {
         continue;
       }
       yield key;
+      count++;
+      if (limit !== void 0 && count >= limit) {
+        break;
+      }
     }
   }
-  async *whereStream(condition, limit, order = "asc") {
+  async *whereStream(condition, options) {
+    const { filterValues, limit, order = "asc" } = options ?? {};
     const driverKey = this.getDriverKey(condition);
     if (!driverKey) return;
     const value = condition[driverKey];
@@ -3203,8 +3244,12 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
       earlyTerminate
     );
     let count = 0;
+    const intersection = filterValues && filterValues.size > 0 ? filterValues : null;
     for await (const pair of generator) {
       const [k, v] = pair;
+      if (intersection && !intersection.has(k)) {
+        continue;
+      }
       let isMatch = true;
       for (const key in condition) {
         if (key === driverKey) continue;
@@ -3224,16 +3269,16 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
       }
     }
   }
-  async keys(condition, filterValues, order = "asc") {
+  async keys(condition, options) {
     const set = /* @__PURE__ */ new Set();
-    for await (const key of this.keysStream(condition, filterValues, void 0, order)) {
+    for await (const key of this.keysStream(condition, options)) {
       set.add(key);
     }
     return set;
   }
-  async where(condition, order = "asc") {
+  async where(condition, options) {
     const map = /* @__PURE__ */ new Map();
-    for await (const [key, value] of this.whereStream(condition, void 0, order)) {
+    for await (const [key, value] of this.whereStream(condition, options)) {
       map.set(key, value);
     }
     return map;
@@ -3462,6 +3507,12 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
   }
   async delete(key, value) {
     return this.writeLock(0, async () => {
+      if (value === void 0) {
+        value = await this.get(key);
+      }
+      if (value === void 0) {
+        return;
+      }
       let node = await this.insertableNodeByPrimary(value);
       let found = false;
       while (true) {

package/dist/types/BPTreeAsync.d.ts

@@ -10,5 +10,5 @@ export declare class BPTreeAsync<K, V> extends BPTreeAsyncTransaction<K, V> {
      */
     createTransaction(): Promise<BPTreeAsyncTransaction<K, V>>;
     insert(key: K, value: V): Promise<void>;
-    delete(key: K, value: V): Promise<void>;
+    delete(key: K, value?: V): Promise<void>;
 }

package/dist/types/BPTreeSync.d.ts

@@ -10,5 +10,5 @@ export declare class BPTreeSync<K, V> extends BPTreeSyncTransaction<K, V> {
      */
     createTransaction(): BPTreeSyncTransaction<K, V>;
     insert(key: K, value: V): void;
-    delete(key: K, value: V): void;
+    delete(key: K, value?: V): void;
 }

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

@@ -1,5 +1,5 @@
 import type { TransactionEntry, TransactionResult } from 'mvcc-api';
-import type { BPTreeCondition, BPTreeConstructorOption, BPTreeUnknownNode, Deferred, BPTreeLeafNode, BPTreeNodeKey, BPTreePair, SerializableData, BPTreeNode, BPTreeMVCC } from '../types';
+import type { BPTreeCondition, BPTreeConstructorOption, BPTreeUnknownNode, Deferred, BPTreeLeafNode, BPTreeNodeKey, BPTreePair, SerializableData, BPTreeNode, BPTreeMVCC, BPTreeSearchOption } from '../types';
 import { ValueComparator } from './ValueComparator';
 import { SerializeStrategy } from './SerializeStrategy';
 export declare abstract class BPTreeTransaction<K, V> {
@@ -55,6 +55,13 @@ export declare abstract class BPTreeTransaction<K, V> {
         tree: T;
         condition: BPTreeCondition<unknown>;
     } | null;
+    /**
+     * Checks for conflicts between multiple transactions.
+     *
+     * @param transactions Array of BPTreeTransaction instances to check
+     * @returns An array of keys that are in conflict. Empty array if no conflicts.
+     */
+    static CheckConflicts<K, V>(transactions: BPTreeTransaction<K, V>[]): string[];
     /**
      * Returns the ID of the root node.
      * @returns The root node ID.
@@ -100,28 +107,44 @@ export declare abstract class BPTreeTransaction<K, V> {
      * This method is used to initialize the stored tree and recover data.
      * If it is not called, the tree will not function.
      */
+    abstract init(): Deferred<void>;
     /**
-     * After creating a tree instance, it must be called.
-     * This method is used to initialize the stored tree and recover data.
-     * If it is not called, the tree will not function.
+     * Retrieves the value associated with the given key.
+     * @param key The key to search for.
+     * @returns A Deferred that resolves to the value if found, or undefined if not found.
      */
-    abstract init(): Deferred<void>;
+    abstract get(key: K): Deferred<V | undefined>;
+    /**
+     * Returns a generator that yields keys satisfying the given condition.
+     * This is a memory-efficient way to iterate through keys when dealing with large result sets.
+     * @param condition The search condition (e.g., gt, lt, equal, like).
+     * @param options Search options including filterValues, limit, and order.
+     * @returns An async or synchronous generator yielding keys of type K.
+     */
+    abstract keysStream(condition: BPTreeCondition<V>, options?: BPTreeSearchOption<K>): AsyncGenerator<K> | Generator<K>;
+    /**
+     * Returns a generator that yields [key, value] pairs satisfying the given condition.
+     * This is a memory-efficient way to iterate through pairs when dealing with large result sets.
+     * @param condition The search condition (e.g., gt, lt, equal, like).
+     * @param options Search options including filterValues, limit, and order.
+     * @returns An async or synchronous generator yielding [K, V] tuples.
+     */
+    abstract whereStream(condition: BPTreeCondition<V>, options?: BPTreeSearchOption<K>): AsyncGenerator<[K, V]> | Generator<[K, V]>;
     /**
      * It searches for a key within the tree. The result is returned as an array sorted in ascending order based on the value.
      * The result is key set instance, and you can use the `gt`, `lt`, `gte`, `lte`, `equal`, `notEqual`, `like` condition statements.
      * This method operates much faster than first searching with `where` and then retrieving only the key list.
      * @param condition You can use the `gt`, `lt`, `gte`, `lte`, `equal`, `notEqual`, `like` condition statements.
-     * @param filterValues The `Set` containing values to check for intersection.
-     * Returns a `Set` containing values that are common to both the input `Set` and the intersection `Set`.
-     * If this parameter is not provided, it searches for all keys inserted into the tree.
+     * @param options Search options including filterValues, limit, and order.
      */
-    abstract keys(condition: BPTreeCondition<V>, filterValues?: Set<K>): Deferred<Set<K>>;
+    abstract keys(condition: BPTreeCondition<V>, options?: BPTreeSearchOption<K>): Deferred<Set<K>>;
     /**
      * It searches for a value within the tree. The result is returned as an array sorted in ascending order based on the value.
      * The result includes the key and value attributes, and you can use the `gt`, `lt`, `gte`, `lte`, `equal`, `notEqual`, `like` condition statements.
      * @param condition You can use the `gt`, `lt`, `gte`, `lte`, `equal`, `notEqual`, `like` condition statements.
+     * @param options Search options including filterValues, limit, and order.
      */
-    abstract where(condition: BPTreeCondition<V>): Deferred<BPTreePair<K, V>>;
+    abstract where(condition: BPTreeCondition<V>, options?: BPTreeSearchOption<K>): Deferred<BPTreePair<K, V>>;
     /**
      * You enter the key and value as a pair. You can later search for the pair by value.
      * This data is stored in the tree, sorted in ascending order of value.
@@ -133,8 +156,9 @@ export declare abstract class BPTreeTransaction<K, V> {
      * Deletes the pair that matches the key and value.
      * @param key The key of the pair. This key must be unique.
      * @param value The value of the pair.
+     * @warning If the 'value' is not specified, a full scan will be performed to find the value associated with the key, which may lead to performance degradation.
      */
-    abstract delete(key: K, value: V): Deferred<void>;
+    abstract delete(key: K, value?: V): Deferred<void>;
     /**
      * It returns whether there is a value in the tree.
      * @param key The key value to search for. This key must be unique.

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

@@ -1,5 +1,5 @@
 import type { TransactionResult } from 'mvcc-api';
-import type { AsyncBPTreeMVCC, BPTreeCondition, BPTreeConstructorOption, BPTreeLeafNode, BPTreeNode, BPTreeNodeKey, BPTreeOrder, BPTreePair, BPTreeUnknownNode, SerializableData, SerializeStrategyHead } from '../types';
+import type { AsyncBPTreeMVCC, BPTreeCondition, BPTreeConstructorOption, BPTreeLeafNode, BPTreeNode, BPTreeNodeKey, BPTreePair, BPTreeUnknownNode, SerializableData, SerializeStrategyHead, BPTreeSearchOption } from '../types';
 import { Ryoiki } from 'ryoiki';
 import { BPTreeTransaction } from '../base/BPTreeTransaction';
 import { SerializeStrategyAsync } from '../SerializeStrategyAsync';
@@ -37,13 +37,13 @@ export declare class BPTreeAsyncTransaction<K, V> extends BPTreeTransaction<K, V
     protected _initInternal(): Promise<void>;
     exists(key: K, value: V): Promise<boolean>;
     get(key: K): Promise<V | undefined>;
-    keysStream(condition: BPTreeCondition<V>, filterValues?: Set<K>, limit?: number, order?: BPTreeOrder): AsyncGenerator<K>;
-    whereStream(condition: BPTreeCondition<V>, limit?: number, order?: BPTreeOrder): AsyncGenerator<[K, V]>;
-    keys(condition: BPTreeCondition<V>, filterValues?: Set<K>, order?: BPTreeOrder): Promise<Set<K>>;
-    where(condition: BPTreeCondition<V>, order?: BPTreeOrder): Promise<BPTreePair<K, V>>;
+    keysStream(condition: BPTreeCondition<V>, options?: BPTreeSearchOption<K>): AsyncGenerator<K>;
+    whereStream(condition: BPTreeCondition<V>, options?: BPTreeSearchOption<K>): AsyncGenerator<[K, V]>;
+    keys(condition: BPTreeCondition<V>, options?: BPTreeSearchOption<K>): Promise<Set<K>>;
+    where(condition: BPTreeCondition<V>, options?: BPTreeSearchOption<K>): Promise<BPTreePair<K, V>>;
     insert(key: K, value: V): Promise<void>;
     protected _deleteEntry(node: BPTreeUnknownNode<K, V>, key: BPTreeNodeKey<K>): Promise<BPTreeUnknownNode<K, V>>;
-    delete(key: K, value: V): Promise<void>;
+    delete(key: K, value?: V): Promise<void>;
     getHeadData(): Promise<SerializableData>;
     setHeadData(data: SerializableData): Promise<void>;
     commit(label?: string): Promise<TransactionResult<string, BPTreeNode<K, V>>>;

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

@@ -1,5 +1,5 @@
 import type { TransactionResult } from 'mvcc-api';
-import type { BPTreeCondition, BPTreeConstructorOption, BPTreeLeafNode, BPTreeNode, BPTreeNodeKey, BPTreeOrder, BPTreePair, BPTreeUnknownNode, SerializableData, SerializeStrategyHead, SyncBPTreeMVCC } from '../types';
+import type { BPTreeCondition, BPTreeConstructorOption, BPTreeLeafNode, BPTreeNode, BPTreeNodeKey, BPTreePair, BPTreeUnknownNode, SerializableData, SerializeStrategyHead, SyncBPTreeMVCC, BPTreeSearchOption } from '../types';
 import { BPTreeTransaction } from '../base/BPTreeTransaction';
 import { SerializeStrategySync } from '../SerializeStrategySync';
 import { ValueComparator } from '../base/ValueComparator';
@@ -34,13 +34,13 @@ export declare class BPTreeSyncTransaction<K, V> extends BPTreeTransaction<K, V>
     protected _initInternal(): void;
     exists(key: K, value: V): boolean;
     get(key: K): V | undefined;
-    keysStream(condition: BPTreeCondition<V>, filterValues?: Set<K>, limit?: number, order?: BPTreeOrder): Generator<K>;
-    whereStream(condition: BPTreeCondition<V>, limit?: number, order?: BPTreeOrder): Generator<[K, V]>;
-    keys(condition: BPTreeCondition<V>, filterValues?: Set<K>, order?: BPTreeOrder): Set<K>;
-    where(condition: BPTreeCondition<V>, order?: BPTreeOrder): BPTreePair<K, V>;
+    keysStream(condition: BPTreeCondition<V>, options?: BPTreeSearchOption<K>): Generator<K>;
+    whereStream(condition: BPTreeCondition<V>, options?: BPTreeSearchOption<K>): Generator<[K, V]>;
+    keys(condition: BPTreeCondition<V>, options?: BPTreeSearchOption<K>): Set<K>;
+    where(condition: BPTreeCondition<V>, options?: BPTreeSearchOption<K>): BPTreePair<K, V>;
     insert(key: K, value: V): void;
     protected _deleteEntry(node: BPTreeUnknownNode<K, V>, key: BPTreeNodeKey<K>): BPTreeUnknownNode<K, V>;
-    delete(key: K, value: V): void;
+    delete(key: K, value?: V): void;
     getHeadData(): SerializableData;
     setHeadData(data: SerializableData): void;
     commit(label?: string): TransactionResult<string, BPTreeNode<K, V>>;

package/dist/types/types/index.d.ts

@@ -52,6 +52,11 @@ export type BPTreeCondition<V> = Partial<{
  * - `'desc'`: Descending order - traverses from right to left
  */
 export type BPTreeOrder = 'asc' | 'desc';
+export interface BPTreeSearchOption<K> {
+    filterValues?: Set<K>;
+    limit?: number;
+    order?: BPTreeOrder;
+}
 export type BPTreePair<K, V> = Map<K, V>;
 export type BPTreeUnknownNode<K, V> = BPTreeInternalNode<K, V> | BPTreeLeafNode<K, V>;
 export interface BPTreeConstructorOption {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "serializable-bptree",
-  "version": "8.1.6",
+  "version": "8.2.0",
   "description": "Store the B+tree flexibly, not only in-memory.",
   "types": "./dist/types/index.d.ts",
   "main": "./dist/cjs/index.cjs",
@@ -38,13 +38,13 @@
   "license": "MIT",
   "devDependencies": {
     "@types/jest": "^30.0.0",
-    "esbuild": "^0.27.2",
+    "esbuild": "^0.27.3",
     "jest": "^30.2.0",
     "ts-jest": "^29.4.6",
     "typescript": "^5.9.3"
   },
   "dependencies": {
-    "mvcc-api": "^1.3.3",
+    "mvcc-api": "^1.3.4",
     "ryoiki": "^1.2.0"
   }
 }