serializable-bptree 9.0.1 → 9.0.3

package/dist/cjs/index.cjs

@@ -3236,6 +3236,9 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
     this._verifierMapCached = createVerifierMap(this.comparator, this._cachedRegexp, ensureValues);
     this._searchConfigsCached = createSearchConfigs(this.comparator, ensureValues);
   }
+  getRootNode() {
+    return this.getNode(this.rootId);
+  }
   // ─── Legacy protected methods (delegating to ops) ────────────────
   getNode(id) {
     return this._ops.getNode(id);
@@ -4674,6 +4677,9 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
       this.lock.writeUnlock(lockId);
     });
   }
+  async getRootNode() {
+    return this.getNode(this.rootId);
+  }
   // ─── Legacy protected methods (delegating to ops) ────────────────
   async getNode(id) {
     return this._ops.getNode(id);
@@ -4990,8 +4996,6 @@ var BPTreePureSync = class {
   comparator;
   option;
   _cachedRegexp = /* @__PURE__ */ new Map();
-  _ctx;
-  _ops;
   _verifierMap;
   _searchConfigs;
   constructor(strategy, comparator, option) {
@@ -5005,7 +5009,7 @@ var BPTreePureSync = class {
   _ensureValues(v) {
     return Array.isArray(v) ? v : [v];
   }
-  _createOps() {
+  _createReadOps() {
     const strategy = this.strategy;
     return {
       getNode(id) {
@@ -5072,16 +5076,35 @@ var BPTreePureSync = class {
     }
     return { ops, flush };
   }
+  _readCtx() {
+    const head = this.strategy.readHead();
+    if (head === null) {
+      throw new Error("Tree not initialized. Call init() first.");
+    }
+    return { rootId: head.root, order: head.order };
+  }
+  _createCtx() {
+    const strategy = this.strategy;
+    const head = strategy.readHead();
+    if (head === null) {
+      throw new Error("Tree not initialized. Call init() first.");
+    }
+    return {
+      rootId: head.root,
+      order: head.order,
+      headData: () => strategy.head.data
+    };
+  }
   init() {
     const { ops, flush } = this._createBufferedOps();
-    this._ctx = {
+    const ctx = {
       rootId: "",
       order: this.strategy.order,
       headData: () => this.strategy.head.data
     };
     initOp(
       ops,
-      this._ctx,
+      ctx,
       this.strategy.order,
       this.strategy.head,
       (head) => {
@@ -5089,23 +5112,19 @@ var BPTreePureSync = class {
       }
     );
     flush();
-    this._ops = this._createOps();
   }
-  /**
-   * Returns the ID of the root node.
-   */
+  getRootNode() {
+    const ctx = this._readCtx();
+    return this.strategy.read(ctx.rootId);
+  }
   getRootId() {
-    return this._ctx.rootId;
+    const ctx = this._readCtx();
+    return ctx.rootId;
   }
-  /**
-   * Returns the order of the B+Tree.
-   */
   getOrder() {
-    return this._ctx.order;
+    const ctx = this._readCtx();
+    return ctx.order;
   }
-  /**
-   * Verified if the value satisfies the condition.
-   */
   verify(nodeValue, condition) {
     for (const key in condition) {
       const verifyFn = this._verifierMap[key];
@@ -5118,15 +5137,18 @@ var BPTreePureSync = class {
   }
   // ─── Query ───────────────────────────────────────────────────────
   get(key) {
-    return getOp(this._ops, this._ctx.rootId, key);
+    const ctx = this._readCtx();
+    return getOp(this._createReadOps(), ctx.rootId, key);
   }
   exists(key, value) {
-    return existsOp(this._ops, this._ctx.rootId, key, value, this.comparator);
+    const ctx = this._readCtx();
+    return existsOp(this._createReadOps(), ctx.rootId, key, value, this.comparator);
   }
   *keysStream(condition, options) {
+    const ctx = this._readCtx();
     yield* keysStreamOp(
-      this._ops,
-      this._ctx.rootId,
+      this._createReadOps(),
+      ctx.rootId,
       condition,
       this.comparator,
       this._verifierMap,
@@ -5136,9 +5158,10 @@ var BPTreePureSync = class {
     );
   }
   *whereStream(condition, options) {
+    const ctx = this._readCtx();
     yield* whereStreamOp(
-      this._ops,
-      this._ctx.rootId,
+      this._createReadOps(),
+      ctx.rootId,
       condition,
       this.comparator,
       this._verifierMap,
@@ -5164,27 +5187,31 @@ var BPTreePureSync = class {
   // ─── Mutation ────────────────────────────────────────────────────
   insert(key, value) {
     const { ops, flush } = this._createBufferedOps();
-    insertOp(ops, this._ctx, key, value, this.comparator);
+    const ctx = this._createCtx();
+    insertOp(ops, ctx, key, value, this.comparator);
     flush();
   }
   delete(key, value) {
     const { ops, flush } = this._createBufferedOps();
-    deleteOp(ops, this._ctx, key, this.comparator, value);
+    const ctx = this._createCtx();
+    deleteOp(ops, ctx, key, this.comparator, value);
     flush();
   }
   batchInsert(entries) {
     const { ops, flush } = this._createBufferedOps();
-    batchInsertOp(ops, this._ctx, entries, this.comparator);
+    const ctx = this._createCtx();
+    batchInsertOp(ops, ctx, entries, this.comparator);
     flush();
   }
   bulkLoad(entries) {
     const { ops, flush } = this._createBufferedOps();
-    bulkLoadOp(ops, this._ctx, entries, this.comparator);
+    const ctx = this._createCtx();
+    bulkLoadOp(ops, ctx, entries, this.comparator);
     flush();
   }
   // ─── Head Data ───────────────────────────────────────────────────
   getHeadData() {
-    const head = this._ops.readHead();
+    const head = this.strategy.readHead();
     if (head === null) {
       throw new Error("Head not found");
     }
@@ -5214,8 +5241,6 @@ var BPTreePureAsync = class {
   option;
   lock = new Ryoiki2();
   _cachedRegexp = /* @__PURE__ */ new Map();
-  _ctx;
-  _ops;
   _verifierMap;
   _searchConfigs;
   constructor(strategy, comparator, option) {
@@ -5229,7 +5254,7 @@ var BPTreePureAsync = class {
   _ensureValues(v) {
     return Array.isArray(v) ? v : [v];
   }
-  _createOps() {
+  _createReadOps() {
     const strategy = this.strategy;
     return {
       async getNode(id) {
@@ -5296,6 +5321,25 @@ var BPTreePureAsync = class {
     }
     return { ops, flush };
   }
+  async _readCtx() {
+    const head = await this.strategy.readHead();
+    if (head === null) {
+      throw new Error("Tree not initialized. Call init() first.");
+    }
+    return { rootId: head.root, order: head.order };
+  }
+  async _createCtx() {
+    const strategy = this.strategy;
+    const head = await strategy.readHead();
+    if (head === null) {
+      throw new Error("Tree not initialized. Call init() first.");
+    }
+    return {
+      rootId: head.root,
+      order: head.order,
+      headData: () => strategy.head.data
+    };
+  }
   async writeLock(fn) {
     let lockId;
     return this.lock.writeLock(async (_lockId) => {
@@ -5308,14 +5352,14 @@ var BPTreePureAsync = class {
   async init() {
     return this.writeLock(async () => {
       const { ops, flush } = this._createBufferedOps();
-      this._ctx = {
+      const ctx = {
         rootId: "",
         order: this.strategy.order,
         headData: () => this.strategy.head.data
       };
       await initOpAsync(
         ops,
-        this._ctx,
+        ctx,
         this.strategy.order,
         this.strategy.head,
         (head) => {
@@ -5323,14 +5367,19 @@ var BPTreePureAsync = class {
         }
       );
       await flush();
-      this._ops = this._createOps();
     });
   }
-  getRootId() {
-    return this._ctx.rootId;
+  async getRootNode() {
+    const ctx = await this._readCtx();
+    return await this.strategy.read(ctx.rootId);
   }
-  getOrder() {
-    return this._ctx.order;
+  async getRootId() {
+    const ctx = await this._readCtx();
+    return ctx.rootId;
+  }
+  async getOrder() {
+    const ctx = await this._readCtx();
+    return ctx.order;
   }
   verify(nodeValue, condition) {
     for (const key in condition) {
@@ -5342,18 +5391,21 @@ var BPTreePureAsync = class {
   }
   // ─── Query ───────────────────────────────────────────────────────
   async get(key) {
-    return getOpAsync(this._ops, this._ctx.rootId, key);
+    const ctx = await this._readCtx();
+    return getOpAsync(this._createReadOps(), ctx.rootId, key);
   }
   async exists(key, value) {
-    return existsOpAsync(this._ops, this._ctx.rootId, key, value, this.comparator);
+    const ctx = await this._readCtx();
+    return existsOpAsync(this._createReadOps(), ctx.rootId, key, value, this.comparator);
   }
   async *keysStream(condition, options) {
     let lockId;
     try {
       lockId = await this.lock.readLock([0, 0.1], async (id) => id);
+      const ctx = await this._readCtx();
       yield* keysStreamOpAsync(
-        this._ops,
-        this._ctx.rootId,
+        this._createReadOps(),
+        ctx.rootId,
         condition,
         this.comparator,
         this._verifierMap,
@@ -5369,9 +5421,10 @@ var BPTreePureAsync = class {
     let lockId;
     try {
       lockId = await this.lock.readLock([0, 0.1], async (id) => id);
+      const ctx = await this._readCtx();
       yield* whereStreamOpAsync(
-        this._ops,
-        this._ctx.rootId,
+        this._createReadOps(),
+        ctx.rootId,
         condition,
         this.comparator,
         this._verifierMap,
@@ -5401,34 +5454,38 @@ var BPTreePureAsync = class {
   async insert(key, value) {
     return this.writeLock(async () => {
       const { ops, flush } = this._createBufferedOps();
-      await insertOpAsync(ops, this._ctx, key, value, this.comparator);
+      const ctx = await this._createCtx();
+      await insertOpAsync(ops, ctx, key, value, this.comparator);
       await flush();
     });
   }
   async delete(key, value) {
     return this.writeLock(async () => {
       const { ops, flush } = this._createBufferedOps();
-      await deleteOpAsync(ops, this._ctx, key, this.comparator, value);
+      const ctx = await this._createCtx();
+      await deleteOpAsync(ops, ctx, key, this.comparator, value);
       await flush();
     });
   }
   async batchInsert(entries) {
     return this.writeLock(async () => {
       const { ops, flush } = this._createBufferedOps();
-      await batchInsertOpAsync(ops, this._ctx, entries, this.comparator);
+      const ctx = await this._createCtx();
+      await batchInsertOpAsync(ops, ctx, entries, this.comparator);
       await flush();
     });
   }
   async bulkLoad(entries) {
     return this.writeLock(async () => {
       const { ops, flush } = this._createBufferedOps();
-      await bulkLoadOpAsync(ops, this._ctx, entries, this.comparator);
+      const ctx = await this._createCtx();
+      await bulkLoadOpAsync(ops, ctx, entries, this.comparator);
       await flush();
     });
   }
   // ─── Head Data ───────────────────────────────────────────────────
   async getHeadData() {
-    const head = await this._ops.readHead();
+    const head = await this.strategy.readHead();
     if (head === null) throw new Error("Head not found");
     return head.data;
   }

package/dist/esm/index.mjs

@@ -3198,6 +3198,9 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
     this._verifierMapCached = createVerifierMap(this.comparator, this._cachedRegexp, ensureValues);
     this._searchConfigsCached = createSearchConfigs(this.comparator, ensureValues);
   }
+  getRootNode() {
+    return this.getNode(this.rootId);
+  }
   // ─── Legacy protected methods (delegating to ops) ────────────────
   getNode(id) {
     return this._ops.getNode(id);
@@ -4636,6 +4639,9 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
       this.lock.writeUnlock(lockId);
     });
   }
+  async getRootNode() {
+    return this.getNode(this.rootId);
+  }
   // ─── Legacy protected methods (delegating to ops) ────────────────
   async getNode(id) {
     return this._ops.getNode(id);
@@ -4952,8 +4958,6 @@ var BPTreePureSync = class {
   comparator;
   option;
   _cachedRegexp = /* @__PURE__ */ new Map();
-  _ctx;
-  _ops;
   _verifierMap;
   _searchConfigs;
   constructor(strategy, comparator, option) {
@@ -4967,7 +4971,7 @@ var BPTreePureSync = class {
   _ensureValues(v) {
     return Array.isArray(v) ? v : [v];
   }
-  _createOps() {
+  _createReadOps() {
     const strategy = this.strategy;
     return {
       getNode(id) {
@@ -5034,16 +5038,35 @@ var BPTreePureSync = class {
     }
     return { ops, flush };
   }
+  _readCtx() {
+    const head = this.strategy.readHead();
+    if (head === null) {
+      throw new Error("Tree not initialized. Call init() first.");
+    }
+    return { rootId: head.root, order: head.order };
+  }
+  _createCtx() {
+    const strategy = this.strategy;
+    const head = strategy.readHead();
+    if (head === null) {
+      throw new Error("Tree not initialized. Call init() first.");
+    }
+    return {
+      rootId: head.root,
+      order: head.order,
+      headData: () => strategy.head.data
+    };
+  }
   init() {
     const { ops, flush } = this._createBufferedOps();
-    this._ctx = {
+    const ctx = {
       rootId: "",
       order: this.strategy.order,
       headData: () => this.strategy.head.data
     };
     initOp(
       ops,
-      this._ctx,
+      ctx,
       this.strategy.order,
       this.strategy.head,
       (head) => {
@@ -5051,23 +5074,19 @@ var BPTreePureSync = class {
       }
     );
     flush();
-    this._ops = this._createOps();
   }
-  /**
-   * Returns the ID of the root node.
-   */
+  getRootNode() {
+    const ctx = this._readCtx();
+    return this.strategy.read(ctx.rootId);
+  }
   getRootId() {
-    return this._ctx.rootId;
+    const ctx = this._readCtx();
+    return ctx.rootId;
   }
-  /**
-   * Returns the order of the B+Tree.
-   */
   getOrder() {
-    return this._ctx.order;
+    const ctx = this._readCtx();
+    return ctx.order;
   }
-  /**
-   * Verified if the value satisfies the condition.
-   */
   verify(nodeValue, condition) {
     for (const key in condition) {
       const verifyFn = this._verifierMap[key];
@@ -5080,15 +5099,18 @@ var BPTreePureSync = class {
   }
   // ─── Query ───────────────────────────────────────────────────────
   get(key) {
-    return getOp(this._ops, this._ctx.rootId, key);
+    const ctx = this._readCtx();
+    return getOp(this._createReadOps(), ctx.rootId, key);
   }
   exists(key, value) {
-    return existsOp(this._ops, this._ctx.rootId, key, value, this.comparator);
+    const ctx = this._readCtx();
+    return existsOp(this._createReadOps(), ctx.rootId, key, value, this.comparator);
   }
   *keysStream(condition, options) {
+    const ctx = this._readCtx();
     yield* keysStreamOp(
-      this._ops,
-      this._ctx.rootId,
+      this._createReadOps(),
+      ctx.rootId,
       condition,
       this.comparator,
       this._verifierMap,
@@ -5098,9 +5120,10 @@ var BPTreePureSync = class {
     );
   }
   *whereStream(condition, options) {
+    const ctx = this._readCtx();
     yield* whereStreamOp(
-      this._ops,
-      this._ctx.rootId,
+      this._createReadOps(),
+      ctx.rootId,
       condition,
       this.comparator,
       this._verifierMap,
@@ -5126,27 +5149,31 @@ var BPTreePureSync = class {
   // ─── Mutation ────────────────────────────────────────────────────
   insert(key, value) {
     const { ops, flush } = this._createBufferedOps();
-    insertOp(ops, this._ctx, key, value, this.comparator);
+    const ctx = this._createCtx();
+    insertOp(ops, ctx, key, value, this.comparator);
     flush();
   }
   delete(key, value) {
     const { ops, flush } = this._createBufferedOps();
-    deleteOp(ops, this._ctx, key, this.comparator, value);
+    const ctx = this._createCtx();
+    deleteOp(ops, ctx, key, this.comparator, value);
     flush();
   }
   batchInsert(entries) {
     const { ops, flush } = this._createBufferedOps();
-    batchInsertOp(ops, this._ctx, entries, this.comparator);
+    const ctx = this._createCtx();
+    batchInsertOp(ops, ctx, entries, this.comparator);
     flush();
   }
   bulkLoad(entries) {
     const { ops, flush } = this._createBufferedOps();
-    bulkLoadOp(ops, this._ctx, entries, this.comparator);
+    const ctx = this._createCtx();
+    bulkLoadOp(ops, ctx, entries, this.comparator);
     flush();
   }
   // ─── Head Data ───────────────────────────────────────────────────
   getHeadData() {
-    const head = this._ops.readHead();
+    const head = this.strategy.readHead();
     if (head === null) {
       throw new Error("Head not found");
     }
@@ -5176,8 +5203,6 @@ var BPTreePureAsync = class {
   option;
   lock = new Ryoiki2();
   _cachedRegexp = /* @__PURE__ */ new Map();
-  _ctx;
-  _ops;
   _verifierMap;
   _searchConfigs;
   constructor(strategy, comparator, option) {
@@ -5191,7 +5216,7 @@ var BPTreePureAsync = class {
   _ensureValues(v) {
     return Array.isArray(v) ? v : [v];
   }
-  _createOps() {
+  _createReadOps() {
     const strategy = this.strategy;
     return {
       async getNode(id) {
@@ -5258,6 +5283,25 @@ var BPTreePureAsync = class {
     }
     return { ops, flush };
   }
+  async _readCtx() {
+    const head = await this.strategy.readHead();
+    if (head === null) {
+      throw new Error("Tree not initialized. Call init() first.");
+    }
+    return { rootId: head.root, order: head.order };
+  }
+  async _createCtx() {
+    const strategy = this.strategy;
+    const head = await strategy.readHead();
+    if (head === null) {
+      throw new Error("Tree not initialized. Call init() first.");
+    }
+    return {
+      rootId: head.root,
+      order: head.order,
+      headData: () => strategy.head.data
+    };
+  }
   async writeLock(fn) {
     let lockId;
     return this.lock.writeLock(async (_lockId) => {
@@ -5270,14 +5314,14 @@ var BPTreePureAsync = class {
   async init() {
     return this.writeLock(async () => {
       const { ops, flush } = this._createBufferedOps();
-      this._ctx = {
+      const ctx = {
         rootId: "",
         order: this.strategy.order,
         headData: () => this.strategy.head.data
       };
       await initOpAsync(
         ops,
-        this._ctx,
+        ctx,
         this.strategy.order,
         this.strategy.head,
         (head) => {
@@ -5285,14 +5329,19 @@ var BPTreePureAsync = class {
         }
       );
       await flush();
-      this._ops = this._createOps();
     });
   }
-  getRootId() {
-    return this._ctx.rootId;
+  async getRootNode() {
+    const ctx = await this._readCtx();
+    return await this.strategy.read(ctx.rootId);
   }
-  getOrder() {
-    return this._ctx.order;
+  async getRootId() {
+    const ctx = await this._readCtx();
+    return ctx.rootId;
+  }
+  async getOrder() {
+    const ctx = await this._readCtx();
+    return ctx.order;
   }
   verify(nodeValue, condition) {
     for (const key in condition) {
@@ -5304,18 +5353,21 @@ var BPTreePureAsync = class {
   }
   // ─── Query ───────────────────────────────────────────────────────
   async get(key) {
-    return getOpAsync(this._ops, this._ctx.rootId, key);
+    const ctx = await this._readCtx();
+    return getOpAsync(this._createReadOps(), ctx.rootId, key);
   }
   async exists(key, value) {
-    return existsOpAsync(this._ops, this._ctx.rootId, key, value, this.comparator);
+    const ctx = await this._readCtx();
+    return existsOpAsync(this._createReadOps(), ctx.rootId, key, value, this.comparator);
   }
   async *keysStream(condition, options) {
     let lockId;
     try {
       lockId = await this.lock.readLock([0, 0.1], async (id) => id);
+      const ctx = await this._readCtx();
       yield* keysStreamOpAsync(
-        this._ops,
-        this._ctx.rootId,
+        this._createReadOps(),
+        ctx.rootId,
         condition,
         this.comparator,
         this._verifierMap,
@@ -5331,9 +5383,10 @@ var BPTreePureAsync = class {
     let lockId;
     try {
       lockId = await this.lock.readLock([0, 0.1], async (id) => id);
+      const ctx = await this._readCtx();
       yield* whereStreamOpAsync(
-        this._ops,
-        this._ctx.rootId,
+        this._createReadOps(),
+        ctx.rootId,
         condition,
         this.comparator,
         this._verifierMap,
@@ -5363,34 +5416,38 @@ var BPTreePureAsync = class {
   async insert(key, value) {
     return this.writeLock(async () => {
       const { ops, flush } = this._createBufferedOps();
-      await insertOpAsync(ops, this._ctx, key, value, this.comparator);
+      const ctx = await this._createCtx();
+      await insertOpAsync(ops, ctx, key, value, this.comparator);
       await flush();
     });
   }
   async delete(key, value) {
     return this.writeLock(async () => {
       const { ops, flush } = this._createBufferedOps();
-      await deleteOpAsync(ops, this._ctx, key, this.comparator, value);
+      const ctx = await this._createCtx();
+      await deleteOpAsync(ops, ctx, key, this.comparator, value);
       await flush();
     });
   }
   async batchInsert(entries) {
     return this.writeLock(async () => {
       const { ops, flush } = this._createBufferedOps();
-      await batchInsertOpAsync(ops, this._ctx, entries, this.comparator);
+      const ctx = await this._createCtx();
+      await batchInsertOpAsync(ops, ctx, entries, this.comparator);
       await flush();
     });
   }
   async bulkLoad(entries) {
     return this.writeLock(async () => {
       const { ops, flush } = this._createBufferedOps();
-      await bulkLoadOpAsync(ops, this._ctx, entries, this.comparator);
+      const ctx = await this._createCtx();
+      await bulkLoadOpAsync(ops, ctx, entries, this.comparator);
       await flush();
     });
   }
   // ─── Head Data ───────────────────────────────────────────────────
   async getHeadData() {
-    const head = await this._ops.readHead();
+    const head = await this.strategy.readHead();
     if (head === null) throw new Error("Head not found");
     return head.data;
   }

package/dist/types/BPTreePureAsync.d.ts

@@ -1,26 +1,27 @@
-import type { BPTreeCondition, BPTreeConstructorOption, BPTreePair, BPTreeSearchOption, SerializableData } from './types';
+import type { BPTreeCondition, BPTreeConstructorOption, BPTreePair, BPTreeSearchOption, BPTreeUnknownNode, SerializableData } from './types';
+import { Ryoiki } from 'ryoiki';
 import { SerializeStrategyAsync } from './SerializeStrategyAsync';
 import { ValueComparator } from './base/ValueComparator';
 import { BPTreeTransaction } from './base/BPTreeTransaction';
-import { Ryoiki } from 'ryoiki';
 export declare class BPTreePureAsync<K, V> {
     protected readonly strategy: SerializeStrategyAsync<K, V>;
     protected readonly comparator: ValueComparator<V>;
     protected readonly option: BPTreeConstructorOption;
     protected readonly lock: Ryoiki;
     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;
+    private _createReadOps;
     private _createBufferedOps;
+    private _readCtx;
+    private _createCtx;
     protected writeLock<T>(fn: () => Promise<T>): Promise<T>;
     init(): Promise<void>;
-    getRootId(): string;
-    getOrder(): number;
+    getRootNode(): Promise<BPTreeUnknownNode<K, V>>;
+    getRootId(): Promise<string>;
+    getOrder(): Promise<number>;
     verify(nodeValue: V, condition: BPTreeCondition<V>): boolean;
     get(key: K): Promise<V | undefined>;
     exists(key: K, value: V): Promise<boolean>;

package/dist/types/BPTreePureSync.d.ts

@@ -1,4 +1,4 @@
-import type { BPTreeCondition, BPTreeConstructorOption, BPTreePair, BPTreeSearchOption, SerializableData } from './types';
+import type { BPTreeCondition, BPTreeConstructorOption, BPTreePair, BPTreeSearchOption, BPTreeUnknownNode, SerializableData } from './types';
 import { SerializeStrategySync } from './SerializeStrategySync';
 import { ValueComparator } from './base/ValueComparator';
 import { BPTreeTransaction } from './base/BPTreeTransaction';
@@ -7,26 +7,18 @@ export declare class BPTreePureSync<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;
+    private _createReadOps;
     private _createBufferedOps;
+    private _readCtx;
+    private _createCtx;
     init(): void;
-    /**
-     * Returns the ID of the root node.
-     */
+    getRootNode(): BPTreeUnknownNode<K, V>;
     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;

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

@@ -57,6 +57,11 @@ export declare abstract class BPTreeTransaction<K, V> {
      * @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 root node of the B+Tree.
+     * @returns The root node.
+     */
+    abstract getRootNode(): Deferred<BPTreeUnknownNode<K, V>>;
     /**
      * Returns the ID of the root node.
      * @returns The root node ID.

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

@@ -20,6 +20,7 @@ export declare class BPTreeAsyncTransaction<K, V> extends BPTreeTransaction<K, V
     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>;
+    getRootNode(): Promise<BPTreeUnknownNode<K, V>>;
     protected getNode(id: string): Promise<BPTreeUnknownNode<K, V>>;
     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>;

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

@@ -17,6 +17,7 @@ export declare class BPTreeSyncTransaction<K, V> extends BPTreeTransaction<K, V>
     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;
+    getRootNode(): BPTreeUnknownNode<K, V>;
     protected getNode(id: string): BPTreeUnknownNode<K, V>;
     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;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "serializable-bptree",
-  "version": "9.0.1",
+  "version": "9.0.3",
   "description": "Store the B+tree flexibly, not only in-memory.",
   "types": "./dist/types/index.d.ts",
   "main": "./dist/cjs/index.cjs",