serializable-bptree 9.0.0 → 9.0.2

package/dist/cjs/index.cjs

@@ -4990,8 +4990,6 @@ var BPTreePureSync = class {
   comparator;
   option;
   _cachedRegexp = /* @__PURE__ */ new Map();
-  _ctx;
-  _ops;
   _verifierMap;
   _searchConfigs;
   constructor(strategy, comparator, option) {
@@ -5005,7 +5003,7 @@ var BPTreePureSync = class {
   _ensureValues(v) {
     return Array.isArray(v) ? v : [v];
   }
-  _createOps() {
+  _createReadOps() {
     const strategy = this.strategy;
     return {
       getNode(id) {
@@ -5014,51 +5012,112 @@ var BPTreePureSync = class {
       createNode(leaf, keys, values, parent = null, next = null, prev = null) {
         const id = strategy.id(leaf);
         const node = { id, keys, values, leaf, parent, next, prev };
-        strategy.write(id, node);
+        return node;
+      },
+      updateNode() {
+      },
+      deleteNode() {
+      },
+      readHead() {
+        return strategy.readHead();
+      },
+      writeHead() {
+      }
+    };
+  }
+  _createBufferedOps() {
+    const strategy = this.strategy;
+    const writeBuffer = /* @__PURE__ */ new Map();
+    const deleteBuffer = /* @__PURE__ */ new Set();
+    let headBuffer = null;
+    const ops = {
+      getNode(id) {
+        const buffered = writeBuffer.get(id);
+        if (buffered) return buffered;
+        return strategy.read(id);
+      },
+      createNode(leaf, keys, values, parent = null, next = null, prev = null) {
+        const id = strategy.id(leaf);
+        const node = { id, keys, values, leaf, parent, next, prev };
+        writeBuffer.set(id, node);
         return node;
       },
       updateNode(node) {
-        strategy.write(node.id, node);
+        writeBuffer.set(node.id, node);
       },
       deleteNode(node) {
-        strategy.delete(node.id);
+        deleteBuffer.add(node.id);
+        writeBuffer.delete(node.id);
       },
       readHead() {
+        if (headBuffer) return headBuffer;
         return strategy.readHead();
       },
       writeHead(head) {
-        strategy.writeHead(head);
+        headBuffer = head;
       }
     };
+    function flush() {
+      for (const id of deleteBuffer) {
+        strategy.delete(id);
+      }
+      for (const [id, node] of writeBuffer) {
+        strategy.write(id, node);
+      }
+      if (headBuffer) {
+        strategy.writeHead(headBuffer);
+      }
+    }
+    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() {
-    this._ops = this._createOps();
-    this._ctx = {
+    const { ops, flush } = this._createBufferedOps();
+    const ctx = {
       rootId: "",
       order: this.strategy.order,
       headData: () => this.strategy.head.data
     };
     initOp(
-      this._ops,
-      this._ctx,
+      ops,
+      ctx,
       this.strategy.order,
       this.strategy.head,
       (head) => {
         this.strategy.head = head;
       }
     );
+    flush();
   }
   /**
    * Returns the ID of the root node.
    */
   getRootId() {
-    return this._ctx.rootId;
+    return this._readCtx().rootId;
   }
   /**
    * Returns the order of the B+Tree.
    */
   getOrder() {
-    return this._ctx.order;
+    return this._readCtx().order;
   }
   /**
    * Verified if the value satisfies the condition.
@@ -5075,15 +5134,18 @@ var BPTreePureSync = class {
   }
   // ─── Query ───────────────────────────────────────────────────────
   get(key) {
-    return getOp(this._ops, this._ctx.rootId, key);
+    const { rootId } = this._readCtx();
+    return getOp(this._createReadOps(), rootId, key);
   }
   exists(key, value) {
-    return existsOp(this._ops, this._ctx.rootId, key, value, this.comparator);
+    const { rootId } = this._readCtx();
+    return existsOp(this._createReadOps(), rootId, key, value, this.comparator);
   }
   *keysStream(condition, options) {
+    const { rootId } = this._readCtx();
     yield* keysStreamOp(
-      this._ops,
-      this._ctx.rootId,
+      this._createReadOps(),
+      rootId,
       condition,
       this.comparator,
       this._verifierMap,
@@ -5093,9 +5155,10 @@ var BPTreePureSync = class {
     );
   }
   *whereStream(condition, options) {
+    const { rootId } = this._readCtx();
     yield* whereStreamOp(
-      this._ops,
-      this._ctx.rootId,
+      this._createReadOps(),
+      rootId,
       condition,
       this.comparator,
       this._verifierMap,
@@ -5120,35 +5183,49 @@ var BPTreePureSync = class {
   }
   // ─── Mutation ────────────────────────────────────────────────────
   insert(key, value) {
-    insertOp(this._ops, this._ctx, key, value, this.comparator);
+    const { ops, flush } = this._createBufferedOps();
+    const ctx = this._createCtx();
+    insertOp(ops, ctx, key, value, this.comparator);
+    flush();
   }
   delete(key, value) {
-    deleteOp(this._ops, this._ctx, key, this.comparator, value);
+    const { ops, flush } = this._createBufferedOps();
+    const ctx = this._createCtx();
+    deleteOp(ops, ctx, key, this.comparator, value);
+    flush();
   }
   batchInsert(entries) {
-    batchInsertOp(this._ops, this._ctx, entries, this.comparator);
+    const { ops, flush } = this._createBufferedOps();
+    const ctx = this._createCtx();
+    batchInsertOp(ops, ctx, entries, this.comparator);
+    flush();
   }
   bulkLoad(entries) {
-    bulkLoadOp(this._ops, this._ctx, entries, this.comparator);
+    const { ops, flush } = this._createBufferedOps();
+    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");
     }
     return head.data;
   }
   setHeadData(data) {
-    const head = this._ops.readHead();
+    const { ops, flush } = this._createBufferedOps();
+    const head = ops.readHead();
     if (head === null) {
       throw new Error("Head not found");
     }
-    this._ops.writeHead({
+    ops.writeHead({
       root: head.root,
       order: head.order,
       data
     });
+    flush();
   }
   // ─── Static utilities ────────────────────────────────────────────
   static ChooseDriver = BPTreeTransaction.ChooseDriver;
@@ -5159,9 +5236,8 @@ var BPTreePureAsync = class {
   strategy;
   comparator;
   option;
+  lock = new Ryoiki2();
   _cachedRegexp = /* @__PURE__ */ new Map();
-  _ctx;
-  _ops;
   _verifierMap;
   _searchConfigs;
   constructor(strategy, comparator, option) {
@@ -5175,7 +5251,7 @@ var BPTreePureAsync = class {
   _ensureValues(v) {
     return Array.isArray(v) ? v : [v];
   }
-  _createOps() {
+  _createReadOps() {
     const strategy = this.strategy;
     return {
       async getNode(id) {
@@ -5184,45 +5260,117 @@ var BPTreePureAsync = class {
       async createNode(leaf, keys, values, parent = null, next = null, prev = null) {
         const id = await strategy.id(leaf);
         const node = { id, keys, values, leaf, parent, next, prev };
-        await strategy.write(id, node);
+        return node;
+      },
+      async updateNode() {
+      },
+      async deleteNode() {
+      },
+      async readHead() {
+        return await strategy.readHead();
+      },
+      async writeHead() {
+      }
+    };
+  }
+  _createBufferedOps() {
+    const strategy = this.strategy;
+    const writeBuffer = /* @__PURE__ */ new Map();
+    const deleteBuffer = /* @__PURE__ */ new Set();
+    let headBuffer = null;
+    const ops = {
+      async getNode(id) {
+        const buffered = writeBuffer.get(id);
+        if (buffered) return buffered;
+        return await strategy.read(id);
+      },
+      async createNode(leaf, keys, values, parent = null, next = null, prev = null) {
+        const id = await strategy.id(leaf);
+        const node = { id, keys, values, leaf, parent, next, prev };
+        writeBuffer.set(id, node);
         return node;
       },
       async updateNode(node) {
-        await strategy.write(node.id, node);
+        writeBuffer.set(node.id, node);
       },
       async deleteNode(node) {
-        await strategy.delete(node.id);
+        deleteBuffer.add(node.id);
+        writeBuffer.delete(node.id);
       },
       async readHead() {
+        if (headBuffer) return headBuffer;
         return await strategy.readHead();
       },
       async writeHead(head) {
-        await strategy.writeHead(head);
+        headBuffer = head;
       }
     };
+    async function flush() {
+      for (const id of deleteBuffer) {
+        await strategy.delete(id);
+      }
+      for (const [id, node] of writeBuffer) {
+        await strategy.write(id, node);
+      }
+      if (headBuffer) {
+        await strategy.writeHead(headBuffer);
+      }
+    }
+    return { ops, flush };
   }
-  async init() {
-    this._ops = this._createOps();
-    this._ctx = {
-      rootId: "",
-      order: this.strategy.order,
-      headData: () => this.strategy.head.data
+  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
     };
-    await initOpAsync(
-      this._ops,
-      this._ctx,
-      this.strategy.order,
-      this.strategy.head,
-      (head) => {
-        this.strategy.head = head;
-      }
-    );
   }
-  getRootId() {
-    return this._ctx.rootId;
+  async writeLock(fn) {
+    let lockId;
+    return this.lock.writeLock(async (_lockId) => {
+      lockId = _lockId;
+      return fn();
+    }).finally(() => {
+      this.lock.writeUnlock(lockId);
+    });
   }
-  getOrder() {
-    return this._ctx.order;
+  async init() {
+    return this.writeLock(async () => {
+      const { ops, flush } = this._createBufferedOps();
+      const ctx = {
+        rootId: "",
+        order: this.strategy.order,
+        headData: () => this.strategy.head.data
+      };
+      await initOpAsync(
+        ops,
+        ctx,
+        this.strategy.order,
+        this.strategy.head,
+        (head) => {
+          this.strategy.head = head;
+        }
+      );
+      await flush();
+    });
+  }
+  async getRootId() {
+    return (await this._readCtx()).rootId;
+  }
+  async getOrder() {
+    return (await this._readCtx()).order;
   }
   verify(nodeValue, condition) {
     for (const key in condition) {
@@ -5234,34 +5382,50 @@ var BPTreePureAsync = class {
   }
   // ─── Query ───────────────────────────────────────────────────────
   async get(key) {
-    return getOpAsync(this._ops, this._ctx.rootId, key);
+    const { rootId } = await this._readCtx();
+    return getOpAsync(this._createReadOps(), rootId, key);
   }
   async exists(key, value) {
-    return existsOpAsync(this._ops, this._ctx.rootId, key, value, this.comparator);
+    const { rootId } = await this._readCtx();
+    return existsOpAsync(this._createReadOps(), rootId, key, value, this.comparator);
   }
   async *keysStream(condition, options) {
-    yield* keysStreamOpAsync(
-      this._ops,
-      this._ctx.rootId,
-      condition,
-      this.comparator,
-      this._verifierMap,
-      this._searchConfigs,
-      this._ensureValues,
-      options
-    );
+    let lockId;
+    try {
+      lockId = await this.lock.readLock([0, 0.1], async (id) => id);
+      const { rootId } = await this._readCtx();
+      yield* keysStreamOpAsync(
+        this._createReadOps(),
+        rootId,
+        condition,
+        this.comparator,
+        this._verifierMap,
+        this._searchConfigs,
+        this._ensureValues,
+        options
+      );
+    } finally {
+      if (lockId) this.lock.readUnlock(lockId);
+    }
   }
   async *whereStream(condition, options) {
-    yield* whereStreamOpAsync(
-      this._ops,
-      this._ctx.rootId,
-      condition,
-      this.comparator,
-      this._verifierMap,
-      this._searchConfigs,
-      this._ensureValues,
-      options
-    );
+    let lockId;
+    try {
+      lockId = await this.lock.readLock([0, 0.1], async (id) => id);
+      const { rootId } = await this._readCtx();
+      yield* whereStreamOpAsync(
+        this._createReadOps(),
+        rootId,
+        condition,
+        this.comparator,
+        this._verifierMap,
+        this._searchConfigs,
+        this._ensureValues,
+        options
+      );
+    } finally {
+      if (lockId) this.lock.readUnlock(lockId);
+    }
   }
   async keys(condition, options) {
     const set = /* @__PURE__ */ new Set();
@@ -5279,27 +5443,51 @@ var BPTreePureAsync = class {
   }
   // ─── Mutation ────────────────────────────────────────────────────
   async insert(key, value) {
-    await insertOpAsync(this._ops, this._ctx, key, value, this.comparator);
+    return this.writeLock(async () => {
+      const { ops, flush } = this._createBufferedOps();
+      const ctx = await this._createCtx();
+      await insertOpAsync(ops, ctx, key, value, this.comparator);
+      await flush();
+    });
   }
   async delete(key, value) {
-    await deleteOpAsync(this._ops, this._ctx, key, this.comparator, value);
+    return this.writeLock(async () => {
+      const { ops, flush } = this._createBufferedOps();
+      const ctx = await this._createCtx();
+      await deleteOpAsync(ops, ctx, key, this.comparator, value);
+      await flush();
+    });
   }
   async batchInsert(entries) {
-    await batchInsertOpAsync(this._ops, this._ctx, entries, this.comparator);
+    return this.writeLock(async () => {
+      const { ops, flush } = this._createBufferedOps();
+      const ctx = await this._createCtx();
+      await batchInsertOpAsync(ops, ctx, entries, this.comparator);
+      await flush();
+    });
   }
   async bulkLoad(entries) {
-    await bulkLoadOpAsync(this._ops, this._ctx, entries, this.comparator);
+    return this.writeLock(async () => {
+      const { ops, flush } = this._createBufferedOps();
+      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;
   }
   async setHeadData(data) {
-    const head = await this._ops.readHead();
-    if (head === null) throw new Error("Head not found");
-    await this._ops.writeHead({ root: head.root, order: head.order, data });
+    return this.writeLock(async () => {
+      const { ops, flush } = this._createBufferedOps();
+      const head = await ops.readHead();
+      if (head === null) throw new Error("Head not found");
+      await ops.writeHead({ root: head.root, order: head.order, data });
+      await flush();
+    });
   }
   // ─── Static utilities ────────────────────────────────────────────
   static ChooseDriver = BPTreeTransaction.ChooseDriver;

package/dist/esm/index.mjs

@@ -4952,8 +4952,6 @@ var BPTreePureSync = class {
   comparator;
   option;
   _cachedRegexp = /* @__PURE__ */ new Map();
-  _ctx;
-  _ops;
   _verifierMap;
   _searchConfigs;
   constructor(strategy, comparator, option) {
@@ -4967,7 +4965,7 @@ var BPTreePureSync = class {
   _ensureValues(v) {
     return Array.isArray(v) ? v : [v];
   }
-  _createOps() {
+  _createReadOps() {
     const strategy = this.strategy;
     return {
       getNode(id) {
@@ -4976,51 +4974,112 @@ var BPTreePureSync = class {
       createNode(leaf, keys, values, parent = null, next = null, prev = null) {
         const id = strategy.id(leaf);
         const node = { id, keys, values, leaf, parent, next, prev };
-        strategy.write(id, node);
+        return node;
+      },
+      updateNode() {
+      },
+      deleteNode() {
+      },
+      readHead() {
+        return strategy.readHead();
+      },
+      writeHead() {
+      }
+    };
+  }
+  _createBufferedOps() {
+    const strategy = this.strategy;
+    const writeBuffer = /* @__PURE__ */ new Map();
+    const deleteBuffer = /* @__PURE__ */ new Set();
+    let headBuffer = null;
+    const ops = {
+      getNode(id) {
+        const buffered = writeBuffer.get(id);
+        if (buffered) return buffered;
+        return strategy.read(id);
+      },
+      createNode(leaf, keys, values, parent = null, next = null, prev = null) {
+        const id = strategy.id(leaf);
+        const node = { id, keys, values, leaf, parent, next, prev };
+        writeBuffer.set(id, node);
         return node;
       },
       updateNode(node) {
-        strategy.write(node.id, node);
+        writeBuffer.set(node.id, node);
       },
       deleteNode(node) {
-        strategy.delete(node.id);
+        deleteBuffer.add(node.id);
+        writeBuffer.delete(node.id);
       },
       readHead() {
+        if (headBuffer) return headBuffer;
         return strategy.readHead();
       },
       writeHead(head) {
-        strategy.writeHead(head);
+        headBuffer = head;
       }
     };
+    function flush() {
+      for (const id of deleteBuffer) {
+        strategy.delete(id);
+      }
+      for (const [id, node] of writeBuffer) {
+        strategy.write(id, node);
+      }
+      if (headBuffer) {
+        strategy.writeHead(headBuffer);
+      }
+    }
+    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() {
-    this._ops = this._createOps();
-    this._ctx = {
+    const { ops, flush } = this._createBufferedOps();
+    const ctx = {
       rootId: "",
       order: this.strategy.order,
       headData: () => this.strategy.head.data
     };
     initOp(
-      this._ops,
-      this._ctx,
+      ops,
+      ctx,
       this.strategy.order,
       this.strategy.head,
       (head) => {
         this.strategy.head = head;
       }
     );
+    flush();
   }
   /**
    * Returns the ID of the root node.
    */
   getRootId() {
-    return this._ctx.rootId;
+    return this._readCtx().rootId;
   }
   /**
    * Returns the order of the B+Tree.
    */
   getOrder() {
-    return this._ctx.order;
+    return this._readCtx().order;
   }
   /**
    * Verified if the value satisfies the condition.
@@ -5037,15 +5096,18 @@ var BPTreePureSync = class {
   }
   // ─── Query ───────────────────────────────────────────────────────
   get(key) {
-    return getOp(this._ops, this._ctx.rootId, key);
+    const { rootId } = this._readCtx();
+    return getOp(this._createReadOps(), rootId, key);
   }
   exists(key, value) {
-    return existsOp(this._ops, this._ctx.rootId, key, value, this.comparator);
+    const { rootId } = this._readCtx();
+    return existsOp(this._createReadOps(), rootId, key, value, this.comparator);
   }
   *keysStream(condition, options) {
+    const { rootId } = this._readCtx();
     yield* keysStreamOp(
-      this._ops,
-      this._ctx.rootId,
+      this._createReadOps(),
+      rootId,
       condition,
       this.comparator,
       this._verifierMap,
@@ -5055,9 +5117,10 @@ var BPTreePureSync = class {
     );
   }
   *whereStream(condition, options) {
+    const { rootId } = this._readCtx();
     yield* whereStreamOp(
-      this._ops,
-      this._ctx.rootId,
+      this._createReadOps(),
+      rootId,
       condition,
       this.comparator,
       this._verifierMap,
@@ -5082,35 +5145,49 @@ var BPTreePureSync = class {
   }
   // ─── Mutation ────────────────────────────────────────────────────
   insert(key, value) {
-    insertOp(this._ops, this._ctx, key, value, this.comparator);
+    const { ops, flush } = this._createBufferedOps();
+    const ctx = this._createCtx();
+    insertOp(ops, ctx, key, value, this.comparator);
+    flush();
   }
   delete(key, value) {
-    deleteOp(this._ops, this._ctx, key, this.comparator, value);
+    const { ops, flush } = this._createBufferedOps();
+    const ctx = this._createCtx();
+    deleteOp(ops, ctx, key, this.comparator, value);
+    flush();
   }
   batchInsert(entries) {
-    batchInsertOp(this._ops, this._ctx, entries, this.comparator);
+    const { ops, flush } = this._createBufferedOps();
+    const ctx = this._createCtx();
+    batchInsertOp(ops, ctx, entries, this.comparator);
+    flush();
   }
   bulkLoad(entries) {
-    bulkLoadOp(this._ops, this._ctx, entries, this.comparator);
+    const { ops, flush } = this._createBufferedOps();
+    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");
     }
     return head.data;
   }
   setHeadData(data) {
-    const head = this._ops.readHead();
+    const { ops, flush } = this._createBufferedOps();
+    const head = ops.readHead();
     if (head === null) {
       throw new Error("Head not found");
     }
-    this._ops.writeHead({
+    ops.writeHead({
       root: head.root,
       order: head.order,
       data
     });
+    flush();
   }
   // ─── Static utilities ────────────────────────────────────────────
   static ChooseDriver = BPTreeTransaction.ChooseDriver;
@@ -5121,9 +5198,8 @@ var BPTreePureAsync = class {
   strategy;
   comparator;
   option;
+  lock = new Ryoiki2();
   _cachedRegexp = /* @__PURE__ */ new Map();
-  _ctx;
-  _ops;
   _verifierMap;
   _searchConfigs;
   constructor(strategy, comparator, option) {
@@ -5137,7 +5213,7 @@ var BPTreePureAsync = class {
   _ensureValues(v) {
     return Array.isArray(v) ? v : [v];
   }
-  _createOps() {
+  _createReadOps() {
     const strategy = this.strategy;
     return {
       async getNode(id) {
@@ -5146,45 +5222,117 @@ var BPTreePureAsync = class {
       async createNode(leaf, keys, values, parent = null, next = null, prev = null) {
         const id = await strategy.id(leaf);
         const node = { id, keys, values, leaf, parent, next, prev };
-        await strategy.write(id, node);
+        return node;
+      },
+      async updateNode() {
+      },
+      async deleteNode() {
+      },
+      async readHead() {
+        return await strategy.readHead();
+      },
+      async writeHead() {
+      }
+    };
+  }
+  _createBufferedOps() {
+    const strategy = this.strategy;
+    const writeBuffer = /* @__PURE__ */ new Map();
+    const deleteBuffer = /* @__PURE__ */ new Set();
+    let headBuffer = null;
+    const ops = {
+      async getNode(id) {
+        const buffered = writeBuffer.get(id);
+        if (buffered) return buffered;
+        return await strategy.read(id);
+      },
+      async createNode(leaf, keys, values, parent = null, next = null, prev = null) {
+        const id = await strategy.id(leaf);
+        const node = { id, keys, values, leaf, parent, next, prev };
+        writeBuffer.set(id, node);
         return node;
       },
       async updateNode(node) {
-        await strategy.write(node.id, node);
+        writeBuffer.set(node.id, node);
       },
       async deleteNode(node) {
-        await strategy.delete(node.id);
+        deleteBuffer.add(node.id);
+        writeBuffer.delete(node.id);
       },
       async readHead() {
+        if (headBuffer) return headBuffer;
         return await strategy.readHead();
       },
       async writeHead(head) {
-        await strategy.writeHead(head);
+        headBuffer = head;
       }
     };
+    async function flush() {
+      for (const id of deleteBuffer) {
+        await strategy.delete(id);
+      }
+      for (const [id, node] of writeBuffer) {
+        await strategy.write(id, node);
+      }
+      if (headBuffer) {
+        await strategy.writeHead(headBuffer);
+      }
+    }
+    return { ops, flush };
   }
-  async init() {
-    this._ops = this._createOps();
-    this._ctx = {
-      rootId: "",
-      order: this.strategy.order,
-      headData: () => this.strategy.head.data
+  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
     };
-    await initOpAsync(
-      this._ops,
-      this._ctx,
-      this.strategy.order,
-      this.strategy.head,
-      (head) => {
-        this.strategy.head = head;
-      }
-    );
   }
-  getRootId() {
-    return this._ctx.rootId;
+  async writeLock(fn) {
+    let lockId;
+    return this.lock.writeLock(async (_lockId) => {
+      lockId = _lockId;
+      return fn();
+    }).finally(() => {
+      this.lock.writeUnlock(lockId);
+    });
   }
-  getOrder() {
-    return this._ctx.order;
+  async init() {
+    return this.writeLock(async () => {
+      const { ops, flush } = this._createBufferedOps();
+      const ctx = {
+        rootId: "",
+        order: this.strategy.order,
+        headData: () => this.strategy.head.data
+      };
+      await initOpAsync(
+        ops,
+        ctx,
+        this.strategy.order,
+        this.strategy.head,
+        (head) => {
+          this.strategy.head = head;
+        }
+      );
+      await flush();
+    });
+  }
+  async getRootId() {
+    return (await this._readCtx()).rootId;
+  }
+  async getOrder() {
+    return (await this._readCtx()).order;
   }
   verify(nodeValue, condition) {
     for (const key in condition) {
@@ -5196,34 +5344,50 @@ var BPTreePureAsync = class {
   }
   // ─── Query ───────────────────────────────────────────────────────
   async get(key) {
-    return getOpAsync(this._ops, this._ctx.rootId, key);
+    const { rootId } = await this._readCtx();
+    return getOpAsync(this._createReadOps(), rootId, key);
   }
   async exists(key, value) {
-    return existsOpAsync(this._ops, this._ctx.rootId, key, value, this.comparator);
+    const { rootId } = await this._readCtx();
+    return existsOpAsync(this._createReadOps(), rootId, key, value, this.comparator);
   }
   async *keysStream(condition, options) {
-    yield* keysStreamOpAsync(
-      this._ops,
-      this._ctx.rootId,
-      condition,
-      this.comparator,
-      this._verifierMap,
-      this._searchConfigs,
-      this._ensureValues,
-      options
-    );
+    let lockId;
+    try {
+      lockId = await this.lock.readLock([0, 0.1], async (id) => id);
+      const { rootId } = await this._readCtx();
+      yield* keysStreamOpAsync(
+        this._createReadOps(),
+        rootId,
+        condition,
+        this.comparator,
+        this._verifierMap,
+        this._searchConfigs,
+        this._ensureValues,
+        options
+      );
+    } finally {
+      if (lockId) this.lock.readUnlock(lockId);
+    }
   }
   async *whereStream(condition, options) {
-    yield* whereStreamOpAsync(
-      this._ops,
-      this._ctx.rootId,
-      condition,
-      this.comparator,
-      this._verifierMap,
-      this._searchConfigs,
-      this._ensureValues,
-      options
-    );
+    let lockId;
+    try {
+      lockId = await this.lock.readLock([0, 0.1], async (id) => id);
+      const { rootId } = await this._readCtx();
+      yield* whereStreamOpAsync(
+        this._createReadOps(),
+        rootId,
+        condition,
+        this.comparator,
+        this._verifierMap,
+        this._searchConfigs,
+        this._ensureValues,
+        options
+      );
+    } finally {
+      if (lockId) this.lock.readUnlock(lockId);
+    }
   }
   async keys(condition, options) {
     const set = /* @__PURE__ */ new Set();
@@ -5241,27 +5405,51 @@ var BPTreePureAsync = class {
   }
   // ─── Mutation ────────────────────────────────────────────────────
   async insert(key, value) {
-    await insertOpAsync(this._ops, this._ctx, key, value, this.comparator);
+    return this.writeLock(async () => {
+      const { ops, flush } = this._createBufferedOps();
+      const ctx = await this._createCtx();
+      await insertOpAsync(ops, ctx, key, value, this.comparator);
+      await flush();
+    });
   }
   async delete(key, value) {
-    await deleteOpAsync(this._ops, this._ctx, key, this.comparator, value);
+    return this.writeLock(async () => {
+      const { ops, flush } = this._createBufferedOps();
+      const ctx = await this._createCtx();
+      await deleteOpAsync(ops, ctx, key, this.comparator, value);
+      await flush();
+    });
   }
   async batchInsert(entries) {
-    await batchInsertOpAsync(this._ops, this._ctx, entries, this.comparator);
+    return this.writeLock(async () => {
+      const { ops, flush } = this._createBufferedOps();
+      const ctx = await this._createCtx();
+      await batchInsertOpAsync(ops, ctx, entries, this.comparator);
+      await flush();
+    });
   }
   async bulkLoad(entries) {
-    await bulkLoadOpAsync(this._ops, this._ctx, entries, this.comparator);
+    return this.writeLock(async () => {
+      const { ops, flush } = this._createBufferedOps();
+      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;
   }
   async setHeadData(data) {
-    const head = await this._ops.readHead();
-    if (head === null) throw new Error("Head not found");
-    await this._ops.writeHead({ root: head.root, order: head.order, data });
+    return this.writeLock(async () => {
+      const { ops, flush } = this._createBufferedOps();
+      const head = await ops.readHead();
+      if (head === null) throw new Error("Head not found");
+      await ops.writeHead({ root: head.root, order: head.order, data });
+      await flush();
+    });
   }
   // ─── Static utilities ────────────────────────────────────────────
   static ChooseDriver = BPTreeTransaction.ChooseDriver;

package/dist/types/BPTreePureAsync.d.ts

@@ -2,21 +2,25 @@ import type { BPTreeCondition, BPTreeConstructorOption, BPTreePair, BPTreeSearch
 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;
+    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

@@ -7,13 +7,14 @@ 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.

package/package.json

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