serializable-bptree 8.4.1 → 9.0.0

package/dist/types/BPTreePureAsync.d.ts

@@ -0,0 +1,34 @@
+import type { BPTreeCondition, BPTreeConstructorOption, BPTreePair, BPTreeSearchOption, SerializableData } from './types';
+import { SerializeStrategyAsync } from './SerializeStrategyAsync';
+import { ValueComparator } from './base/ValueComparator';
+import { BPTreeTransaction } from './base/BPTreeTransaction';
+export declare class BPTreePureAsync<K, V> {
+    protected readonly strategy: SerializeStrategyAsync<K, V>;
+    protected readonly comparator: ValueComparator<V>;
+    protected readonly option: BPTreeConstructorOption;
+    private readonly _cachedRegexp;
+    private _ctx;
+    private _ops;
+    private readonly _verifierMap;
+    private readonly _searchConfigs;
+    constructor(strategy: SerializeStrategyAsync<K, V>, comparator: ValueComparator<V>, option?: BPTreeConstructorOption);
+    private _ensureValues;
+    private _createOps;
+    init(): Promise<void>;
+    getRootId(): string;
+    getOrder(): number;
+    verify(nodeValue: V, condition: BPTreeCondition<V>): boolean;
+    get(key: K): Promise<V | undefined>;
+    exists(key: K, value: V): Promise<boolean>;
+    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>;
+    delete(key: K, value?: V): Promise<void>;
+    batchInsert(entries: [K, V][]): Promise<void>;
+    bulkLoad(entries: [K, V][]): Promise<void>;
+    getHeadData(): Promise<SerializableData>;
+    setHeadData(data: SerializableData): Promise<void>;
+    static ChooseDriver: typeof BPTreeTransaction.ChooseDriver;
+}

package/dist/types/BPTreePureSync.d.ts

@@ -0,0 +1,43 @@
+import type { BPTreeCondition, BPTreeConstructorOption, BPTreePair, BPTreeSearchOption, SerializableData } from './types';
+import { SerializeStrategySync } from './SerializeStrategySync';
+import { ValueComparator } from './base/ValueComparator';
+import { BPTreeTransaction } from './base/BPTreeTransaction';
+export declare class BPTreePureSync<K, V> {
+    protected readonly strategy: SerializeStrategySync<K, V>;
+    protected readonly comparator: ValueComparator<V>;
+    protected readonly option: BPTreeConstructorOption;
+    private readonly _cachedRegexp;
+    private _ctx;
+    private _ops;
+    private readonly _verifierMap;
+    private readonly _searchConfigs;
+    constructor(strategy: SerializeStrategySync<K, V>, comparator: ValueComparator<V>, option?: BPTreeConstructorOption);
+    private _ensureValues;
+    private _createOps;
+    init(): void;
+    /**
+     * Returns the ID of the root node.
+     */
+    getRootId(): string;
+    /**
+     * Returns the order of the B+Tree.
+     */
+    getOrder(): number;
+    /**
+     * Verified if the value satisfies the condition.
+     */
+    verify(nodeValue: V, condition: BPTreeCondition<V>): boolean;
+    get(key: K): V | undefined;
+    exists(key: K, value: V): boolean;
+    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;
+    delete(key: K, value?: V): void;
+    batchInsert(entries: [K, V][]): void;
+    bulkLoad(entries: [K, V][]): void;
+    getHeadData(): SerializableData;
+    setHeadData(data: SerializableData): void;
+    static ChooseDriver: typeof BPTreeTransaction.ChooseDriver;
+}

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

@@ -0,0 +1,33 @@
+import type { BPTreeCondition, BPTreeLeafNode, BPTreeNodeKey, BPTreeUnknownNode, BPTreeSearchOption, SerializableData, SerializeStrategyHead } from '../types';
+import type { BPTreeNodeOpsAsync, BPTreeAlgoContext } from './BPTreeNodeOps';
+import { ValueComparator } from './ValueComparator';
+import { cloneNode, binarySearchValues, insertValueIntoLeaf, createVerifierMap, resolveStartEndConfigs, verify } from './BPTreeAlgorithmSync';
+export { cloneNode, binarySearchValues, insertValueIntoLeaf, createVerifierMap, resolveStartEndConfigs, verify };
+type AsyncSearchConfigEntry<K, V> = {
+    start: (rootId: string, ops: BPTreeNodeOpsAsync<K, V>, v: V[]) => Promise<BPTreeLeafNode<K, V> | null>;
+    end: (rootId: string, ops: BPTreeNodeOpsAsync<K, V>, v: V[]) => Promise<BPTreeLeafNode<K, V> | null>;
+    direction: 1 | -1;
+    earlyTerminate: boolean;
+};
+export declare function createSearchConfigsAsync<K, V>(comparator: ValueComparator<V>, ensureValues: (v: V | V[]) => V[]): Record<keyof BPTreeCondition<V>, Record<'asc' | 'desc', AsyncSearchConfigEntry<K, V>>>;
+export declare function locateLeafAsync<K, V>(ops: BPTreeNodeOpsAsync<K, V>, rootId: string, value: V, comparator: ValueComparator<V>): Promise<BPTreeLeafNode<K, V>>;
+export declare function findLowerBoundLeafAsync<K, V>(ops: BPTreeNodeOpsAsync<K, V>, rootId: string, value: V, comparator: ValueComparator<V>): Promise<BPTreeLeafNode<K, V>>;
+export declare function findUpperBoundLeafAsync<K, V>(ops: BPTreeNodeOpsAsync<K, V>, rootId: string, value: V, comparator: ValueComparator<V>): Promise<BPTreeLeafNode<K, V>>;
+export declare function findOuterBoundaryLeafAsync<K, V>(ops: BPTreeNodeOpsAsync<K, V>, rootId: string, value: V, direction: 1 | -1, comparator: ValueComparator<V>): Promise<BPTreeLeafNode<K, V> | null>;
+export declare function leftestNodeAsync<K, V>(ops: BPTreeNodeOpsAsync<K, V>, rootId: string): Promise<BPTreeLeafNode<K, V>>;
+export declare function rightestNodeAsync<K, V>(ops: BPTreeNodeOpsAsync<K, V>, rootId: string): Promise<BPTreeLeafNode<K, V>>;
+export declare function getPairsGeneratorAsync<K, V>(ops: BPTreeNodeOpsAsync<K, V>, startNode: BPTreeLeafNode<K, V>, endNode: BPTreeLeafNode<K, V> | null, direction: 1 | -1): AsyncGenerator<[K, V]>;
+export declare function insertAtLeafAsync<K, V>(ops: BPTreeNodeOpsAsync<K, V>, node: BPTreeUnknownNode<K, V>, key: BPTreeNodeKey<K>, value: V, comparator: ValueComparator<V>): Promise<BPTreeUnknownNode<K, V>>;
+export declare function insertInParentAsync<K, V>(ops: BPTreeNodeOpsAsync<K, V>, ctx: BPTreeAlgoContext<K, V>, node: BPTreeUnknownNode<K, V>, value: V, newSiblingNode: BPTreeUnknownNode<K, V>): Promise<void>;
+export declare function insertOpAsync<K, V>(ops: BPTreeNodeOpsAsync<K, V>, ctx: BPTreeAlgoContext<K, V>, key: K, value: V, comparator: ValueComparator<V>): Promise<void>;
+export declare function deleteEntryAsync<K, V>(ops: BPTreeNodeOpsAsync<K, V>, ctx: BPTreeAlgoContext<K, V>, node: BPTreeUnknownNode<K, V>, key: BPTreeNodeKey<K>, comparator: ValueComparator<V>): Promise<BPTreeUnknownNode<K, V>>;
+export declare function deleteOpAsync<K, V>(ops: BPTreeNodeOpsAsync<K, V>, ctx: BPTreeAlgoContext<K, V>, key: K, comparator: ValueComparator<V>, value?: V): Promise<void>;
+export declare function batchInsertOpAsync<K, V>(ops: BPTreeNodeOpsAsync<K, V>, ctx: BPTreeAlgoContext<K, V>, entries: [K, V][], comparator: ValueComparator<V>): Promise<void>;
+export declare function bulkLoadOpAsync<K, V>(ops: BPTreeNodeOpsAsync<K, V>, ctx: BPTreeAlgoContext<K, V>, entries: [K, V][], comparator: ValueComparator<V>): Promise<void>;
+export declare function existsOpAsync<K, V>(ops: BPTreeNodeOpsAsync<K, V>, rootId: string, key: K, value: V, comparator: ValueComparator<V>): Promise<boolean>;
+export declare function getOpAsync<K, V>(ops: BPTreeNodeOpsAsync<K, V>, rootId: string, key: K): Promise<V | undefined>;
+export declare function whereStreamOpAsync<K, V>(ops: BPTreeNodeOpsAsync<K, V>, rootId: string, condition: BPTreeCondition<V>, comparator: ValueComparator<V>, verifierMap: Record<keyof BPTreeCondition<V>, (nodeValue: V, value: V | V[]) => boolean>, searchConfigs: Record<keyof BPTreeCondition<V>, Record<'asc' | 'desc', AsyncSearchConfigEntry<K, V>>>, ensureValues: (v: V | V[]) => V[], options?: BPTreeSearchOption<K>): AsyncGenerator<[K, V]>;
+export declare function keysStreamOpAsync<K, V>(ops: BPTreeNodeOpsAsync<K, V>, rootId: string, condition: BPTreeCondition<V>, comparator: ValueComparator<V>, verifierMap: Record<keyof BPTreeCondition<V>, (nodeValue: V, value: V | V[]) => boolean>, searchConfigs: Record<keyof BPTreeCondition<V>, Record<'asc' | 'desc', AsyncSearchConfigEntry<K, V>>>, ensureValues: (v: V | V[]) => V[], options?: BPTreeSearchOption<K>): AsyncGenerator<K>;
+export declare function initOpAsync<K, V>(ops: BPTreeNodeOpsAsync<K, V>, ctx: BPTreeAlgoContext<K, V>, strategyOrder: number, strategyHead: {
+    data: SerializableData;
+}, setStrategyHead: (head: SerializeStrategyHead) => void): Promise<void>;

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

@@ -0,0 +1,47 @@
+import type { BPTreeCondition, BPTreeLeafNode, BPTreeNodeKey, BPTreeUnknownNode, BPTreeSearchOption, SerializableData, SerializeStrategyHead } from '../types';
+import type { BPTreeNodeOps, BPTreeAlgoContext } from './BPTreeNodeOps';
+import { ValueComparator } from './ValueComparator';
+export declare function cloneNode<K, V, T extends BPTreeUnknownNode<K, V>>(node: T): T;
+export declare function binarySearchValues<V>(values: V[], target: V, comparator: ValueComparator<V>, usePrimary?: boolean, upperBound?: boolean): {
+    index: number;
+    found: boolean;
+};
+export declare function insertValueIntoLeaf<K, V>(leaf: BPTreeLeafNode<K, V>, key: K, value: V, comparator: ValueComparator<V>): boolean;
+export declare function createVerifierMap<V>(comparator: ValueComparator<V>, cachedRegexp: Map<string, RegExp>, ensureValues: (v: V | V[]) => V[]): Record<keyof BPTreeCondition<V>, (nodeValue: V, value: V | V[]) => boolean>;
+type SearchConfigEntry<K, V> = {
+    start: (rootId: string, ops: BPTreeNodeOps<K, V>, v: V[]) => BPTreeLeafNode<K, V> | null;
+    end: (rootId: string, ops: BPTreeNodeOps<K, V>, v: V[]) => BPTreeLeafNode<K, V> | null;
+    direction: 1 | -1;
+    earlyTerminate: boolean;
+};
+export declare function createSearchConfigs<K, V>(comparator: ValueComparator<V>, ensureValues: (v: V | V[]) => V[]): Record<keyof BPTreeCondition<V>, Record<'asc' | 'desc', SearchConfigEntry<K, V>>>;
+export declare function resolveStartEndConfigs<V>(condition: BPTreeCondition<V>, order: 'asc' | 'desc', comparator: ValueComparator<V>, ensureValues: (v: V | V[]) => V[]): {
+    startKey: keyof BPTreeCondition<V> | null;
+    endKey: keyof BPTreeCondition<V> | null;
+    startValues: V[];
+    endValues: V[];
+    direction: 1 | -1;
+};
+export declare function verify<V>(nodeValue: V, condition: BPTreeCondition<V>, verifierMap: Record<keyof BPTreeCondition<V>, (nodeValue: V, value: V | V[]) => boolean>): boolean;
+export declare function locateLeaf<K, V>(ops: BPTreeNodeOps<K, V>, rootId: string, value: V, comparator: ValueComparator<V>): BPTreeLeafNode<K, V>;
+export declare function findLowerBoundLeaf<K, V>(ops: BPTreeNodeOps<K, V>, rootId: string, value: V, comparator: ValueComparator<V>): BPTreeLeafNode<K, V>;
+export declare function findUpperBoundLeaf<K, V>(ops: BPTreeNodeOps<K, V>, rootId: string, value: V, comparator: ValueComparator<V>): BPTreeLeafNode<K, V>;
+export declare function findOuterBoundaryLeaf<K, V>(ops: BPTreeNodeOps<K, V>, rootId: string, value: V, direction: 1 | -1, comparator: ValueComparator<V>): BPTreeLeafNode<K, V> | null;
+export declare function leftestNode<K, V>(ops: BPTreeNodeOps<K, V>, rootId: string): BPTreeLeafNode<K, V>;
+export declare function rightestNode<K, V>(ops: BPTreeNodeOps<K, V>, rootId: string): BPTreeLeafNode<K, V>;
+export declare function getPairsGenerator<K, V>(ops: BPTreeNodeOps<K, V>, startNode: BPTreeLeafNode<K, V>, endNode: BPTreeLeafNode<K, V> | null, direction: 1 | -1): Generator<[K, V]>;
+export declare function insertAtLeaf<K, V>(ops: BPTreeNodeOps<K, V>, node: BPTreeUnknownNode<K, V>, key: BPTreeNodeKey<K>, value: V, comparator: ValueComparator<V>): BPTreeUnknownNode<K, V>;
+export declare function insertInParent<K, V>(ops: BPTreeNodeOps<K, V>, ctx: BPTreeAlgoContext<K, V>, node: BPTreeUnknownNode<K, V>, value: V, newSiblingNode: BPTreeUnknownNode<K, V>): void;
+export declare function insertOp<K, V>(ops: BPTreeNodeOps<K, V>, ctx: BPTreeAlgoContext<K, V>, key: K, value: V, comparator: ValueComparator<V>): void;
+export declare function deleteEntry<K, V>(ops: BPTreeNodeOps<K, V>, ctx: BPTreeAlgoContext<K, V>, node: BPTreeUnknownNode<K, V>, key: BPTreeNodeKey<K>, comparator: ValueComparator<V>): BPTreeUnknownNode<K, V>;
+export declare function deleteOp<K, V>(ops: BPTreeNodeOps<K, V>, ctx: BPTreeAlgoContext<K, V>, key: K, comparator: ValueComparator<V>, value?: V): void;
+export declare function batchInsertOp<K, V>(ops: BPTreeNodeOps<K, V>, ctx: BPTreeAlgoContext<K, V>, entries: [K, V][], comparator: ValueComparator<V>): void;
+export declare function bulkLoadOp<K, V>(ops: BPTreeNodeOps<K, V>, ctx: BPTreeAlgoContext<K, V>, entries: [K, V][], comparator: ValueComparator<V>): void;
+export declare function existsOp<K, V>(ops: BPTreeNodeOps<K, V>, rootId: string, key: K, value: V, comparator: ValueComparator<V>): boolean;
+export declare function getOp<K, V>(ops: BPTreeNodeOps<K, V>, rootId: string, key: K): V | undefined;
+export declare function whereStreamOp<K, V>(ops: BPTreeNodeOps<K, V>, rootId: string, condition: BPTreeCondition<V>, comparator: ValueComparator<V>, verifierMap: Record<keyof BPTreeCondition<V>, (nodeValue: V, value: V | V[]) => boolean>, searchConfigs: Record<keyof BPTreeCondition<V>, Record<'asc' | 'desc', SearchConfigEntry<K, V>>>, ensureValues: (v: V | V[]) => V[], options?: BPTreeSearchOption<K>): Generator<[K, V]>;
+export declare function keysStreamOp<K, V>(ops: BPTreeNodeOps<K, V>, rootId: string, condition: BPTreeCondition<V>, comparator: ValueComparator<V>, verifierMap: Record<keyof BPTreeCondition<V>, (nodeValue: V, value: V | V[]) => boolean>, searchConfigs: Record<keyof BPTreeCondition<V>, Record<'asc' | 'desc', SearchConfigEntry<K, V>>>, ensureValues: (v: V | V[]) => V[], options?: BPTreeSearchOption<K>): Generator<K>;
+export declare function initOp<K, V>(ops: BPTreeNodeOps<K, V>, ctx: BPTreeAlgoContext<K, V>, strategyOrder: number, strategyHead: {
+    data: SerializableData;
+}, setStrategyHead: (head: SerializeStrategyHead) => void): void;
+export {};

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

@@ -0,0 +1,34 @@
+import type { BPTreeUnknownNode, SerializableData, SerializeStrategyHead } from '../types';
+/**
+ * Abstraction for B+Tree node access operations.
+ * Both MVCC-based (BPTreeSyncTransaction) and strategy-direct (BPTreePure)
+ * implementations provide this interface to the shared algorithm functions.
+ */
+export interface BPTreeNodeOps<K, V> {
+    getNode(id: string): BPTreeUnknownNode<K, V>;
+    createNode(leaf: boolean, keys: string[] | K[][], values: V[], parent?: string | null, next?: string | null, prev?: string | null): BPTreeUnknownNode<K, V>;
+    updateNode(node: BPTreeUnknownNode<K, V>): void;
+    deleteNode(node: BPTreeUnknownNode<K, V>): void;
+    readHead(): SerializeStrategyHead | null;
+    writeHead(head: SerializeStrategyHead): void;
+}
+/**
+ * Mutable algorithm context passed to B+Tree algorithm functions.
+ * `rootId` is mutable because tree mutations (insert, delete) may change the root.
+ */
+export interface BPTreeAlgoContext<K, V> {
+    rootId: string;
+    order: number;
+    readonly headData: () => SerializableData;
+}
+/**
+ * Async version of BPTreeNodeOps for async B+Tree operations.
+ */
+export interface BPTreeNodeOpsAsync<K, V> {
+    getNode(id: string): Promise<BPTreeUnknownNode<K, V>>;
+    createNode(leaf: boolean, keys: string[] | K[][], values: V[], parent?: string | null, next?: string | null, prev?: string | null): Promise<BPTreeUnknownNode<K, V>>;
+    updateNode(node: BPTreeUnknownNode<K, V>): Promise<void>;
+    deleteNode(node: BPTreeUnknownNode<K, V>): Promise<void>;
+    readHead(): Promise<SerializeStrategyHead | null>;
+    writeHead(head: SerializeStrategyHead): Promise<void>;
+}

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

@@ -3,9 +3,7 @@ import type { BPTreeCondition, BPTreeConstructorOption, BPTreeUnknownNode, Defer
 import { ValueComparator } from './ValueComparator';
 import { SerializeStrategy } from './SerializeStrategy';
 export declare abstract class BPTreeTransaction<K, V> {
-    private readonly _cachedRegexp;
-    protected readonly nodes: Map<string, BPTreeUnknownNode<K, V>>;
-    protected readonly deletedNodeBuffer: Map<string, BPTreeUnknownNode<K, V>>;
+    protected readonly _cachedRegexp: Map<string, RegExp>;
     protected readonly rootTx: BPTreeTransaction<K, V>;
     protected readonly mvccRoot: BPTreeMVCC<K, V>;
     protected readonly mvcc: BPTreeMVCC<K, V>;
@@ -122,6 +120,12 @@ export declare abstract class BPTreeTransaction<K, V> {
      * If it is not called, the tree will not function.
      */
     abstract init(): Deferred<void>;
+    /**
+     * Clears all in-memory caches and re-initializes the tree from storage.
+     * This is equivalent to calling `clear()` followed by `init()`, but reuses the same instance.
+     * Useful when the underlying storage has been modified externally and the tree needs to reflect current state.
+     */
+    abstract reload(): Deferred<void>;
     /**
      * Retrieves the value associated with the given key.
      * @param key The key to search for.
@@ -233,6 +237,7 @@ export declare abstract class BPTreeTransaction<K, V> {
         deleted: TransactionEntry<string, BPTreeNode<K, V>>[];
     };
     protected _clearCache(): void;
+    protected _resetForReload(): void;
     /**
      * Clears all cached nodes.
      * This method is useful for freeing up memory when the tree is no longer needed.

package/dist/types/index.d.ts

@@ -4,5 +4,7 @@ export { BPTreeSync } from './BPTreeSync';
 export { BPTreeSyncTransaction } from './transaction/BPTreeSyncTransaction';
 export { BPTreeAsync } from './BPTreeAsync';
 export { BPTreeAsyncTransaction } from './transaction/BPTreeAsyncTransaction';
+export { BPTreePureSync } from './BPTreePureSync';
+export { BPTreePureAsync } from './BPTreePureAsync';
 export { SerializeStrategySync, InMemoryStoreStrategySync } from './SerializeStrategySync';
 export { SerializeStrategyAsync, InMemoryStoreStrategyAsync } from './SerializeStrategyAsync';

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

@@ -1,6 +1,7 @@
 import type { TransactionResult } from 'mvcc-api';
-import type { AsyncBPTreeMVCC, BPTreeCondition, BPTreeConstructorOption, BPTreeLeafNode, BPTreeNode, BPTreeNodeKey, BPTreePair, BPTreeUnknownNode, SerializableData, SerializeStrategyHead, BPTreeSearchOption } from '../types';
+import type { AsyncBPTreeMVCC, BPTreeCondition, BPTreeConstructorOption, BPTreeNode, BPTreeNodeKey, BPTreePair, BPTreeUnknownNode, SerializableData, SerializeStrategyHead, BPTreeSearchOption, BPTreeLeafNode } from '../types';
 import { Ryoiki } from 'ryoiki';
+import { getPairsGeneratorAsync } from '../base/BPTreeAlgorithmAsync';
 import { BPTreeTransaction } from '../base/BPTreeTransaction';
 import { SerializeStrategyAsync } from '../SerializeStrategyAsync';
 import { ValueComparator } from '../base/ValueComparator';
@@ -12,12 +13,14 @@ export declare class BPTreeAsyncTransaction<K, V> extends BPTreeTransaction<K, V
     protected readonly comparator: ValueComparator<V>;
     protected readonly option: BPTreeConstructorOption;
     protected readonly lock: Ryoiki;
+    private _ops;
+    private _ctx;
+    private _verifierMapCached;
+    private _searchConfigsCached;
     constructor(rootTx: BPTreeAsyncTransaction<K, V> | null, mvccRoot: AsyncBPTreeMVCC<K, V>, mvcc: AsyncBPTreeMVCC<K, V>, strategy: SerializeStrategyAsync<K, V>, comparator: ValueComparator<V>, option?: BPTreeConstructorOption);
+    private _initAlgoContext;
     protected writeLock<T>(id: number, fn: () => Promise<T>): Promise<T>;
     protected getNode(id: string): Promise<BPTreeUnknownNode<K, V>>;
-    /**
-     * Create a new node with a unique ID.
-     */
     protected _createNode(leaf: boolean, keys: string[] | K[][], values: V[], parent?: string | null, next?: string | null, prev?: string | null): Promise<BPTreeUnknownNode<K, V>>;
     protected _updateNode(node: BPTreeUnknownNode<K, V>): Promise<void>;
     protected _deleteNode(node: BPTreeUnknownNode<K, V>): Promise<void>;
@@ -31,9 +34,11 @@ export declare class BPTreeAsyncTransaction<K, V> extends BPTreeTransaction<K, V
     protected findOuterBoundaryLeaf(value: V, direction: 1 | -1): Promise<BPTreeLeafNode<K, V> | null>;
     protected leftestNode(): Promise<BPTreeLeafNode<K, V>>;
     protected rightestNode(): Promise<BPTreeLeafNode<K, V>>;
-    protected getPairsGenerator(startNode: BPTreeLeafNode<K, V>, endNode: BPTreeLeafNode<K, V> | null, direction: 1 | -1): AsyncGenerator<[K, V]>;
+    protected getPairsGenerator(startNode: Parameters<typeof getPairsGeneratorAsync<K, V>>[1], endNode: Parameters<typeof getPairsGeneratorAsync<K, V>>[2], direction: 1 | -1): AsyncGenerator<[BPTreeNodeKey<K>, V], void, unknown>;
     init(): Promise<void>;
     protected _initInternal(): Promise<void>;
+    reload(): Promise<void>;
+    protected _reloadInternal(): Promise<void>;
     exists(key: K, value: V): Promise<boolean>;
     get(key: K): Promise<V | undefined>;
     keysStream(condition: BPTreeCondition<V>, options?: BPTreeSearchOption<K>): AsyncGenerator<K>;

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

@@ -1,5 +1,6 @@
 import type { TransactionResult } from 'mvcc-api';
-import type { BPTreeCondition, BPTreeConstructorOption, BPTreeLeafNode, BPTreeNode, BPTreeNodeKey, BPTreePair, BPTreeUnknownNode, SerializableData, SerializeStrategyHead, SyncBPTreeMVCC, BPTreeSearchOption } from '../types';
+import type { BPTreeCondition, BPTreeConstructorOption, BPTreeNode, BPTreeNodeKey, BPTreePair, BPTreeUnknownNode, SerializableData, SerializeStrategyHead, SyncBPTreeMVCC, BPTreeSearchOption, BPTreeLeafNode } from '../types';
+import { getPairsGenerator } from '../base/BPTreeAlgorithmSync';
 import { BPTreeTransaction } from '../base/BPTreeTransaction';
 import { SerializeStrategySync } from '../SerializeStrategySync';
 import { ValueComparator } from '../base/ValueComparator';
@@ -10,11 +11,13 @@ export declare class BPTreeSyncTransaction<K, V> extends BPTreeTransaction<K, V>
     protected readonly strategy: SerializeStrategySync<K, V>;
     protected readonly comparator: ValueComparator<V>;
     protected readonly option: BPTreeConstructorOption;
+    private _ops;
+    private _ctx;
+    private _verifierMapCached;
+    private _searchConfigsCached;
     constructor(rootTx: BPTreeSyncTransaction<K, V>, mvccRoot: SyncBPTreeMVCC<K, V>, mvcc: SyncBPTreeMVCC<K, V>, strategy: SerializeStrategySync<K, V>, comparator: ValueComparator<V>, option?: BPTreeConstructorOption);
+    private _initAlgoContext;
     protected getNode(id: string): BPTreeUnknownNode<K, V>;
-    /**
-     * Create a new node with a unique ID.
-     */
     protected _createNode(leaf: boolean, keys: string[] | K[][], values: V[], parent?: string | null, next?: string | null, prev?: string | null): BPTreeUnknownNode<K, V>;
     protected _updateNode(node: BPTreeUnknownNode<K, V>): void;
     protected _deleteNode(node: BPTreeUnknownNode<K, V>): void;
@@ -28,9 +31,11 @@ export declare class BPTreeSyncTransaction<K, V> extends BPTreeTransaction<K, V>
     protected findOuterBoundaryLeaf(value: V, direction: 1 | -1): BPTreeLeafNode<K, V> | null;
     protected leftestNode(): BPTreeLeafNode<K, V>;
     protected rightestNode(): BPTreeLeafNode<K, V>;
-    protected getPairsGenerator(startNode: BPTreeLeafNode<K, V>, endNode: BPTreeLeafNode<K, V> | null, direction: 1 | -1): Generator<[K, V]>;
+    protected getPairsGenerator(startNode: Parameters<typeof getPairsGenerator<K, V>>[1], endNode: Parameters<typeof getPairsGenerator<K, V>>[2], direction: 1 | -1): Generator<[BPTreeNodeKey<K>, V], void, unknown>;
     init(): void;
     protected _initInternal(): void;
+    reload(): void;
+    protected _reloadInternal(): void;
     exists(key: K, value: V): boolean;
     get(key: K): V | undefined;
     keysStream(condition: BPTreeCondition<V>, options?: BPTreeSearchOption<K>): Generator<K>;

package/package.json

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