serializable-bptree 9.0.2 → 9.0.4-alpha.0

package/dist/cjs/index.cjs

@@ -2159,13 +2159,7 @@ function insertOp(ops, ctx, key, value, comparator) {
 }
 function deleteEntry(ops, ctx, node, key, comparator) {
   if (!node.leaf) {
-    let keyIndex = -1;
-    for (let i = 0, len = node.keys.length; i < len; i++) {
-      if (node.keys[i] === key) {
-        keyIndex = i;
-        break;
-      }
-    }
+    let keyIndex = node.keys.indexOf(key);
     if (keyIndex !== -1) {
       node = cloneNode(node);
       node.keys.splice(keyIndex, 1);
@@ -2204,17 +2198,15 @@ function deleteEntry(ops, ctx, node, key, comparator) {
     let nextNode = null;
     let prevValue = null;
     let postValue = null;
-    for (let i = 0, len = parentNode.keys.length; i < len; i++) {
-      const nKey = parentNode.keys[i];
-      if (nKey === node.id) {
-        if (i > 0) {
-          prevNode = ops.getNode(parentNode.keys[i - 1]);
-          prevValue = parentNode.values[i - 1];
-        }
-        if (i < parentNode.keys.length - 1) {
-          nextNode = ops.getNode(parentNode.keys[i + 1]);
-          postValue = parentNode.values[i];
-        }
+    let keyIndex = parentNode.keys.indexOf(node.id);
+    if (keyIndex !== -1) {
+      if (keyIndex > 0) {
+        prevNode = ops.getNode(parentNode.keys[keyIndex - 1]);
+        prevValue = parentNode.values[keyIndex - 1];
+      }
+      if (keyIndex < parentNode.keys.length - 1) {
+        nextNode = ops.getNode(parentNode.keys[keyIndex + 1]);
+        postValue = parentNode.values[keyIndex];
       }
     }
     let siblingNode;
@@ -2247,7 +2239,7 @@ function deleteEntry(ops, ctx, node, key, comparator) {
         siblingNode = node;
         node = pTemp;
       }
-      siblingNode.keys.push(...node.keys);
+      siblingNode.keys = siblingNode.keys.concat(node.keys);
       if (!node.leaf) {
         siblingNode.values.push(guess);
       } else {
@@ -2258,7 +2250,7 @@ function deleteEntry(ops, ctx, node, key, comparator) {
           ops.updateNode(n);
         }
       }
-      siblingNode.values.push(...node.values);
+      siblingNode.values = siblingNode.values.concat(node.values);
       if (!siblingNode.leaf) {
         const keys = siblingNode.keys;
         for (let i = 0, len = keys.length; i < len; i++) {
@@ -2306,8 +2298,8 @@ function deleteEntry(ops, ctx, node, key, comparator) {
         if (!node.leaf) {
           pointerP0 = siblingNode.keys.splice(0, 1)[0];
           pointerK0 = siblingNode.values.splice(0, 1)[0];
-          node.keys = [...node.keys, pointerP0];
-          node.values = [...node.values, guess];
+          node.keys = node.keys.concat(pointerP0);
+          node.values = node.values.concat(guess);
           parentNode = cloneNode(ops.getNode(node.parent));
           const pointerIndex = parentNode.keys.indexOf(siblingNode.id);
           if (pointerIndex > 0) {
@@ -2317,8 +2309,8 @@ function deleteEntry(ops, ctx, node, key, comparator) {
         } else {
           pointerP0 = siblingNode.keys.splice(0, 1)[0];
           pointerK0 = siblingNode.values.splice(0, 1)[0];
-          node.keys = [...node.keys, pointerP0];
-          node.values = [...node.values, pointerK0];
+          node.keys = node.keys.concat(pointerP0);
+          node.values = node.values.concat(pointerK0);
           parentNode = cloneNode(ops.getNode(node.parent));
           const pointerIndex = parentNode.keys.indexOf(siblingNode.id);
           if (pointerIndex > 0) {
@@ -3236,6 +3228,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);
@@ -4198,13 +4193,7 @@ async function insertOpAsync(ops, ctx, key, value, comparator) {
 }
 async function deleteEntryAsync(ops, ctx, node, key, comparator) {
   if (!node.leaf) {
-    let keyIndex = -1;
-    for (let i = 0, len = node.keys.length; i < len; i++) {
-      if (node.keys[i] === key) {
-        keyIndex = i;
-        break;
-      }
-    }
+    let keyIndex = node.keys.indexOf(key);
     if (keyIndex !== -1) {
       node = cloneNode(node);
       node.keys.splice(keyIndex, 1);
@@ -4233,16 +4222,15 @@ async function deleteEntryAsync(ops, ctx, node, key, comparator) {
     let nextNode = null;
     let prevValue = null;
     let postValue = null;
-    for (let i = 0, len = parentNode.keys.length; i < len; i++) {
-      if (parentNode.keys[i] === node.id) {
-        if (i > 0) {
-          prevNode = await ops.getNode(parentNode.keys[i - 1]);
-          prevValue = parentNode.values[i - 1];
-        }
-        if (i < parentNode.keys.length - 1) {
-          nextNode = await ops.getNode(parentNode.keys[i + 1]);
-          postValue = parentNode.values[i];
-        }
+    let keyIndex = parentNode.keys.indexOf(node.id);
+    if (keyIndex !== -1) {
+      if (keyIndex > 0) {
+        prevNode = await ops.getNode(parentNode.keys[keyIndex - 1]);
+        prevValue = parentNode.values[keyIndex - 1];
+      }
+      if (keyIndex < parentNode.keys.length - 1) {
+        nextNode = await ops.getNode(parentNode.keys[keyIndex + 1]);
+        postValue = parentNode.values[keyIndex];
       }
     }
     let siblingNode;
@@ -4269,11 +4257,11 @@ async function deleteEntryAsync(ops, ctx, node, key, comparator) {
     siblingNode = cloneNode(siblingNode);
     if (node.values.length + siblingNode.values.length < ctx.order) {
       if (!isPredecessor) {
-        const t = siblingNode;
+        const pTemp = siblingNode;
         siblingNode = node;
-        node = t;
+        node = pTemp;
       }
-      siblingNode.keys.push(...node.keys);
+      siblingNode.keys = siblingNode.keys.concat(node.keys);
       if (!node.leaf) {
         siblingNode.values.push(guess);
       } else {
@@ -4284,7 +4272,7 @@ async function deleteEntryAsync(ops, ctx, node, key, comparator) {
           await ops.updateNode(n);
         }
       }
-      siblingNode.values.push(...node.values);
+      siblingNode.values = siblingNode.values.concat(node.values);
       if (!siblingNode.leaf) {
         for (let i = 0, len = siblingNode.keys.length; i < len; i++) {
           const n = cloneNode(await ops.getNode(siblingNode.keys[i]));
@@ -4328,8 +4316,8 @@ async function deleteEntryAsync(ops, ctx, node, key, comparator) {
         if (!node.leaf) {
           pointerP0 = siblingNode.keys.splice(0, 1)[0];
           pointerK0 = siblingNode.values.splice(0, 1)[0];
-          node.keys = [...node.keys, pointerP0];
-          node.values = [...node.values, guess];
+          node.keys = node.keys.concat(pointerP0);
+          node.values = node.values.concat(guess);
           parentNode = cloneNode(await ops.getNode(node.parent));
           const pi = parentNode.keys.indexOf(siblingNode.id);
           if (pi > 0) {
@@ -4339,8 +4327,8 @@ async function deleteEntryAsync(ops, ctx, node, key, comparator) {
         } else {
           pointerP0 = siblingNode.keys.splice(0, 1)[0];
           pointerK0 = siblingNode.values.splice(0, 1)[0];
-          node.keys = [...node.keys, pointerP0];
-          node.values = [...node.values, pointerK0];
+          node.keys = node.keys.concat(pointerP0);
+          node.values = node.values.concat(pointerK0);
           parentNode = cloneNode(await ops.getNode(node.parent));
           const pi = parentNode.keys.indexOf(siblingNode.id);
           if (pi > 0) {
@@ -4674,6 +4662,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);
@@ -5107,21 +5098,18 @@ var BPTreePureSync = class {
     );
     flush();
   }
-  /**
-   * Returns the ID of the root node.
-   */
+  getRootNode() {
+    const ctx = this._readCtx();
+    return this.strategy.read(ctx.rootId);
+  }
   getRootId() {
-    return this._readCtx().rootId;
+    const ctx = this._readCtx();
+    return ctx.rootId;
   }
-  /**
-   * Returns the order of the B+Tree.
-   */
   getOrder() {
-    return this._readCtx().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];
@@ -5134,18 +5122,18 @@ var BPTreePureSync = class {
   }
   // ─── Query ───────────────────────────────────────────────────────
   get(key) {
-    const { rootId } = this._readCtx();
-    return getOp(this._createReadOps(), rootId, key);
+    const ctx = this._readCtx();
+    return getOp(this._createReadOps(), ctx.rootId, key);
   }
   exists(key, value) {
-    const { rootId } = this._readCtx();
-    return existsOp(this._createReadOps(), rootId, key, value, this.comparator);
+    const ctx = this._readCtx();
+    return existsOp(this._createReadOps(), ctx.rootId, key, value, this.comparator);
   }
   *keysStream(condition, options) {
-    const { rootId } = this._readCtx();
+    const ctx = this._readCtx();
     yield* keysStreamOp(
       this._createReadOps(),
-      rootId,
+      ctx.rootId,
       condition,
       this.comparator,
       this._verifierMap,
@@ -5155,10 +5143,10 @@ var BPTreePureSync = class {
     );
   }
   *whereStream(condition, options) {
-    const { rootId } = this._readCtx();
+    const ctx = this._readCtx();
     yield* whereStreamOp(
       this._createReadOps(),
-      rootId,
+      ctx.rootId,
       condition,
       this.comparator,
       this._verifierMap,
@@ -5366,11 +5354,17 @@ var BPTreePureAsync = class {
       await flush();
     });
   }
+  async getRootNode() {
+    const ctx = await this._readCtx();
+    return await this.strategy.read(ctx.rootId);
+  }
   async getRootId() {
-    return (await this._readCtx()).rootId;
+    const ctx = await this._readCtx();
+    return ctx.rootId;
   }
   async getOrder() {
-    return (await this._readCtx()).order;
+    const ctx = await this._readCtx();
+    return ctx.order;
   }
   verify(nodeValue, condition) {
     for (const key in condition) {
@@ -5382,21 +5376,21 @@ var BPTreePureAsync = class {
   }
   // ─── Query ───────────────────────────────────────────────────────
   async get(key) {
-    const { rootId } = await this._readCtx();
-    return getOpAsync(this._createReadOps(), rootId, key);
+    const ctx = await this._readCtx();
+    return getOpAsync(this._createReadOps(), ctx.rootId, key);
   }
   async exists(key, value) {
-    const { rootId } = await this._readCtx();
-    return existsOpAsync(this._createReadOps(), 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 { rootId } = await this._readCtx();
+      const ctx = await this._readCtx();
       yield* keysStreamOpAsync(
         this._createReadOps(),
-        rootId,
+        ctx.rootId,
         condition,
         this.comparator,
         this._verifierMap,
@@ -5412,10 +5406,10 @@ var BPTreePureAsync = class {
     let lockId;
     try {
       lockId = await this.lock.readLock([0, 0.1], async (id) => id);
-      const { rootId } = await this._readCtx();
+      const ctx = await this._readCtx();
       yield* whereStreamOpAsync(
         this._createReadOps(),
-        rootId,
+        ctx.rootId,
         condition,
         this.comparator,
         this._verifierMap,

package/dist/esm/index.mjs

@@ -2121,13 +2121,7 @@ function insertOp(ops, ctx, key, value, comparator) {
 }
 function deleteEntry(ops, ctx, node, key, comparator) {
   if (!node.leaf) {
-    let keyIndex = -1;
-    for (let i = 0, len = node.keys.length; i < len; i++) {
-      if (node.keys[i] === key) {
-        keyIndex = i;
-        break;
-      }
-    }
+    let keyIndex = node.keys.indexOf(key);
     if (keyIndex !== -1) {
       node = cloneNode(node);
       node.keys.splice(keyIndex, 1);
@@ -2166,17 +2160,15 @@ function deleteEntry(ops, ctx, node, key, comparator) {
     let nextNode = null;
     let prevValue = null;
     let postValue = null;
-    for (let i = 0, len = parentNode.keys.length; i < len; i++) {
-      const nKey = parentNode.keys[i];
-      if (nKey === node.id) {
-        if (i > 0) {
-          prevNode = ops.getNode(parentNode.keys[i - 1]);
-          prevValue = parentNode.values[i - 1];
-        }
-        if (i < parentNode.keys.length - 1) {
-          nextNode = ops.getNode(parentNode.keys[i + 1]);
-          postValue = parentNode.values[i];
-        }
+    let keyIndex = parentNode.keys.indexOf(node.id);
+    if (keyIndex !== -1) {
+      if (keyIndex > 0) {
+        prevNode = ops.getNode(parentNode.keys[keyIndex - 1]);
+        prevValue = parentNode.values[keyIndex - 1];
+      }
+      if (keyIndex < parentNode.keys.length - 1) {
+        nextNode = ops.getNode(parentNode.keys[keyIndex + 1]);
+        postValue = parentNode.values[keyIndex];
       }
     }
     let siblingNode;
@@ -2209,7 +2201,7 @@ function deleteEntry(ops, ctx, node, key, comparator) {
         siblingNode = node;
         node = pTemp;
       }
-      siblingNode.keys.push(...node.keys);
+      siblingNode.keys = siblingNode.keys.concat(node.keys);
       if (!node.leaf) {
         siblingNode.values.push(guess);
       } else {
@@ -2220,7 +2212,7 @@ function deleteEntry(ops, ctx, node, key, comparator) {
           ops.updateNode(n);
         }
       }
-      siblingNode.values.push(...node.values);
+      siblingNode.values = siblingNode.values.concat(node.values);
       if (!siblingNode.leaf) {
         const keys = siblingNode.keys;
         for (let i = 0, len = keys.length; i < len; i++) {
@@ -2268,8 +2260,8 @@ function deleteEntry(ops, ctx, node, key, comparator) {
         if (!node.leaf) {
           pointerP0 = siblingNode.keys.splice(0, 1)[0];
           pointerK0 = siblingNode.values.splice(0, 1)[0];
-          node.keys = [...node.keys, pointerP0];
-          node.values = [...node.values, guess];
+          node.keys = node.keys.concat(pointerP0);
+          node.values = node.values.concat(guess);
           parentNode = cloneNode(ops.getNode(node.parent));
           const pointerIndex = parentNode.keys.indexOf(siblingNode.id);
           if (pointerIndex > 0) {
@@ -2279,8 +2271,8 @@ function deleteEntry(ops, ctx, node, key, comparator) {
         } else {
           pointerP0 = siblingNode.keys.splice(0, 1)[0];
           pointerK0 = siblingNode.values.splice(0, 1)[0];
-          node.keys = [...node.keys, pointerP0];
-          node.values = [...node.values, pointerK0];
+          node.keys = node.keys.concat(pointerP0);
+          node.values = node.values.concat(pointerK0);
           parentNode = cloneNode(ops.getNode(node.parent));
           const pointerIndex = parentNode.keys.indexOf(siblingNode.id);
           if (pointerIndex > 0) {
@@ -3198,6 +3190,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);
@@ -4160,13 +4155,7 @@ async function insertOpAsync(ops, ctx, key, value, comparator) {
 }
 async function deleteEntryAsync(ops, ctx, node, key, comparator) {
   if (!node.leaf) {
-    let keyIndex = -1;
-    for (let i = 0, len = node.keys.length; i < len; i++) {
-      if (node.keys[i] === key) {
-        keyIndex = i;
-        break;
-      }
-    }
+    let keyIndex = node.keys.indexOf(key);
     if (keyIndex !== -1) {
       node = cloneNode(node);
       node.keys.splice(keyIndex, 1);
@@ -4195,16 +4184,15 @@ async function deleteEntryAsync(ops, ctx, node, key, comparator) {
     let nextNode = null;
     let prevValue = null;
     let postValue = null;
-    for (let i = 0, len = parentNode.keys.length; i < len; i++) {
-      if (parentNode.keys[i] === node.id) {
-        if (i > 0) {
-          prevNode = await ops.getNode(parentNode.keys[i - 1]);
-          prevValue = parentNode.values[i - 1];
-        }
-        if (i < parentNode.keys.length - 1) {
-          nextNode = await ops.getNode(parentNode.keys[i + 1]);
-          postValue = parentNode.values[i];
-        }
+    let keyIndex = parentNode.keys.indexOf(node.id);
+    if (keyIndex !== -1) {
+      if (keyIndex > 0) {
+        prevNode = await ops.getNode(parentNode.keys[keyIndex - 1]);
+        prevValue = parentNode.values[keyIndex - 1];
+      }
+      if (keyIndex < parentNode.keys.length - 1) {
+        nextNode = await ops.getNode(parentNode.keys[keyIndex + 1]);
+        postValue = parentNode.values[keyIndex];
       }
     }
     let siblingNode;
@@ -4231,11 +4219,11 @@ async function deleteEntryAsync(ops, ctx, node, key, comparator) {
     siblingNode = cloneNode(siblingNode);
     if (node.values.length + siblingNode.values.length < ctx.order) {
       if (!isPredecessor) {
-        const t = siblingNode;
+        const pTemp = siblingNode;
         siblingNode = node;
-        node = t;
+        node = pTemp;
       }
-      siblingNode.keys.push(...node.keys);
+      siblingNode.keys = siblingNode.keys.concat(node.keys);
       if (!node.leaf) {
         siblingNode.values.push(guess);
       } else {
@@ -4246,7 +4234,7 @@ async function deleteEntryAsync(ops, ctx, node, key, comparator) {
           await ops.updateNode(n);
         }
       }
-      siblingNode.values.push(...node.values);
+      siblingNode.values = siblingNode.values.concat(node.values);
       if (!siblingNode.leaf) {
         for (let i = 0, len = siblingNode.keys.length; i < len; i++) {
           const n = cloneNode(await ops.getNode(siblingNode.keys[i]));
@@ -4290,8 +4278,8 @@ async function deleteEntryAsync(ops, ctx, node, key, comparator) {
         if (!node.leaf) {
           pointerP0 = siblingNode.keys.splice(0, 1)[0];
           pointerK0 = siblingNode.values.splice(0, 1)[0];
-          node.keys = [...node.keys, pointerP0];
-          node.values = [...node.values, guess];
+          node.keys = node.keys.concat(pointerP0);
+          node.values = node.values.concat(guess);
           parentNode = cloneNode(await ops.getNode(node.parent));
           const pi = parentNode.keys.indexOf(siblingNode.id);
           if (pi > 0) {
@@ -4301,8 +4289,8 @@ async function deleteEntryAsync(ops, ctx, node, key, comparator) {
         } else {
           pointerP0 = siblingNode.keys.splice(0, 1)[0];
           pointerK0 = siblingNode.values.splice(0, 1)[0];
-          node.keys = [...node.keys, pointerP0];
-          node.values = [...node.values, pointerK0];
+          node.keys = node.keys.concat(pointerP0);
+          node.values = node.values.concat(pointerK0);
           parentNode = cloneNode(await ops.getNode(node.parent));
           const pi = parentNode.keys.indexOf(siblingNode.id);
           if (pi > 0) {
@@ -4636,6 +4624,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);
@@ -5069,21 +5060,18 @@ var BPTreePureSync = class {
     );
     flush();
   }
-  /**
-   * Returns the ID of the root node.
-   */
+  getRootNode() {
+    const ctx = this._readCtx();
+    return this.strategy.read(ctx.rootId);
+  }
   getRootId() {
-    return this._readCtx().rootId;
+    const ctx = this._readCtx();
+    return ctx.rootId;
   }
-  /**
-   * Returns the order of the B+Tree.
-   */
   getOrder() {
-    return this._readCtx().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];
@@ -5096,18 +5084,18 @@ var BPTreePureSync = class {
   }
   // ─── Query ───────────────────────────────────────────────────────
   get(key) {
-    const { rootId } = this._readCtx();
-    return getOp(this._createReadOps(), rootId, key);
+    const ctx = this._readCtx();
+    return getOp(this._createReadOps(), ctx.rootId, key);
   }
   exists(key, value) {
-    const { rootId } = this._readCtx();
-    return existsOp(this._createReadOps(), rootId, key, value, this.comparator);
+    const ctx = this._readCtx();
+    return existsOp(this._createReadOps(), ctx.rootId, key, value, this.comparator);
   }
   *keysStream(condition, options) {
-    const { rootId } = this._readCtx();
+    const ctx = this._readCtx();
     yield* keysStreamOp(
       this._createReadOps(),
-      rootId,
+      ctx.rootId,
       condition,
       this.comparator,
       this._verifierMap,
@@ -5117,10 +5105,10 @@ var BPTreePureSync = class {
     );
   }
   *whereStream(condition, options) {
-    const { rootId } = this._readCtx();
+    const ctx = this._readCtx();
     yield* whereStreamOp(
       this._createReadOps(),
-      rootId,
+      ctx.rootId,
       condition,
       this.comparator,
       this._verifierMap,
@@ -5328,11 +5316,17 @@ var BPTreePureAsync = class {
       await flush();
     });
   }
+  async getRootNode() {
+    const ctx = await this._readCtx();
+    return await this.strategy.read(ctx.rootId);
+  }
   async getRootId() {
-    return (await this._readCtx()).rootId;
+    const ctx = await this._readCtx();
+    return ctx.rootId;
   }
   async getOrder() {
-    return (await this._readCtx()).order;
+    const ctx = await this._readCtx();
+    return ctx.order;
   }
   verify(nodeValue, condition) {
     for (const key in condition) {
@@ -5344,21 +5338,21 @@ var BPTreePureAsync = class {
   }
   // ─── Query ───────────────────────────────────────────────────────
   async get(key) {
-    const { rootId } = await this._readCtx();
-    return getOpAsync(this._createReadOps(), rootId, key);
+    const ctx = await this._readCtx();
+    return getOpAsync(this._createReadOps(), ctx.rootId, key);
   }
   async exists(key, value) {
-    const { rootId } = await this._readCtx();
-    return existsOpAsync(this._createReadOps(), 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 { rootId } = await this._readCtx();
+      const ctx = await this._readCtx();
       yield* keysStreamOpAsync(
         this._createReadOps(),
-        rootId,
+        ctx.rootId,
         condition,
         this.comparator,
         this._verifierMap,
@@ -5374,10 +5368,10 @@ var BPTreePureAsync = class {
     let lockId;
     try {
       lockId = await this.lock.readLock([0, 0.1], async (id) => id);
-      const { rootId } = await this._readCtx();
+      const ctx = await this._readCtx();
       yield* whereStreamOpAsync(
         this._createReadOps(),
-        rootId,
+        ctx.rootId,
         condition,
         this.comparator,
         this._verifierMap,

package/dist/types/BPTreePureAsync.d.ts

@@ -1,8 +1,8 @@
-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>;
@@ -19,6 +19,7 @@ export declare class BPTreePureAsync<K, V> {
     private _createCtx;
     protected writeLock<T>(fn: () => Promise<T>): Promise<T>;
     init(): Promise<void>;
+    getRootNode(): Promise<BPTreeUnknownNode<K, V>>;
     getRootId(): Promise<string>;
     getOrder(): Promise<number>;
     verify(nodeValue: V, condition: BPTreeCondition<V>): 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';
@@ -16,17 +16,9 @@ export declare class BPTreePureSync<K, V> {
     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.2",
+  "version": "9.0.4-alpha.0",
   "description": "Store the B+tree flexibly, not only in-memory.",
   "types": "./dist/types/index.d.ts",
   "main": "./dist/cjs/index.cjs",