dataply 0.0.9 → 0.0.11

package/dist/cjs/index.js

@@ -71,6 +71,33 @@ var ValueComparator = class {
   isHigher(value, than) {
     return this.asc(value, than) > 0;
   }
+  /**
+   * This method is used for range queries with composite values.
+   * By default, it calls the `asc` method, so existing code works without changes.
+   * 
+   * When using composite values (e.g., `{ k: number, v: number }`), 
+   * override this method to compare only the primary sorting field (e.g., `v`),
+   * ignoring the unique identifier field (e.g., `k`).
+   * 
+   * This enables efficient range queries like `primaryEqual` that find all entries
+   * with the same primary value regardless of their unique identifiers.
+   * 
+   * @param a Value a.
+   * @param b Value b.
+   * @returns Negative if a < b, 0 if equal, positive if a > b (based on primary field only).
+   */
+  primaryAsc(a, b) {
+    return this.asc(a, b);
+  }
+  isPrimarySame(value, than) {
+    return this.primaryAsc(value, than) === 0;
+  }
+  isPrimaryLower(value, than) {
+    return this.primaryAsc(value, than) < 0;
+  }
+  isPrimaryHigher(value, than) {
+    return this.primaryAsc(value, than) > 0;
+  }
 };
 var NumericComparator = class extends ValueComparator {
   asc(a, b) {
@@ -480,6 +507,7 @@ var BPTree = class {
     lt: (nv, v) => this.comparator.isLower(nv, v),
     lte: (nv, v) => this.comparator.isLower(nv, v) || this.comparator.isSame(nv, v),
     equal: (nv, v) => this.comparator.isSame(nv, v),
+    primaryEqual: (nv, v) => this.comparator.isPrimarySame(nv, v),
     notEqual: (nv, v) => this.comparator.isSame(nv, v) === false,
     or: (nv, v) => this.ensureValues(v).some((v2) => this.comparator.isSame(nv, v2)),
     like: (nv, v) => {
@@ -496,6 +524,7 @@ var BPTree = class {
     lt: (v) => this.insertableNode(v),
     lte: (v) => this.insertableNode(v),
     equal: (v) => this.insertableNode(v),
+    primaryEqual: (v) => this.insertableNodeByPrimary(v),
     notEqual: (v) => this.leftestNode(),
     or: (v) => this.insertableNode(this.lowestValue(this.ensureValues(v))),
     like: (v) => this.leftestNode()
@@ -506,6 +535,7 @@ var BPTree = class {
     lt: (v) => null,
     lte: (v) => null,
     equal: (v) => this.insertableEndNode(v, this.verifierDirection.equal),
+    primaryEqual: (v) => null,
     notEqual: (v) => null,
     or: (v) => this.insertableEndNode(
       this.highestValue(this.ensureValues(v)),
@@ -519,10 +549,27 @@ var BPTree = class {
     lt: -1,
     lte: -1,
     equal: 1,
+    primaryEqual: 1,
     notEqual: 1,
     or: 1,
     like: 1
   };
+  /**
+   * Determines whether early termination is allowed for each condition.
+   * When true, the search will stop once a match is found and then a non-match is encountered.
+   * Only applicable for conditions that guarantee contiguous matches in a sorted B+Tree.
+   */
+  verifierEarlyTerminate = {
+    gt: false,
+    gte: false,
+    lt: false,
+    lte: false,
+    equal: true,
+    primaryEqual: true,
+    notEqual: false,
+    or: false,
+    like: false
+  };
   constructor(strategy, comparator, option) {
     this.strategy = strategy;
     this.comparator = comparator;
@@ -633,10 +680,11 @@ var BPTreeSync = class extends BPTree {
       capacity: this.option.capacity ?? 1e3
     });
   }
-  getPairsRightToLeft(value, startNode, endNode, comparator) {
+  getPairsRightToLeft(value, startNode, endNode, comparator, earlyTerminate) {
     const pairs = [];
     let node = startNode;
     let done = false;
+    let hasMatched = false;
     while (!done) {
       if (endNode && node.id === endNode.id) {
         done = true;
@@ -647,12 +695,17 @@ var BPTreeSync = class extends BPTree {
         const nValue = node.values[i];
         const keys = node.keys[i];
         if (comparator(nValue, value)) {
+          hasMatched = true;
           let j = keys.length;
           while (j--) {
             pairs.push([keys[j], nValue]);
           }
+        } else if (earlyTerminate && hasMatched) {
+          done = true;
+          break;
         }
       }
+      if (done) break;
       if (!node.prev) {
         done = true;
         break;
@@ -661,10 +714,11 @@ var BPTreeSync = class extends BPTree {
     }
     return new Map(pairs.reverse());
   }
-  getPairsLeftToRight(value, startNode, endNode, comparator) {
+  getPairsLeftToRight(value, startNode, endNode, comparator, earlyTerminate) {
     const pairs = [];
     let node = startNode;
     let done = false;
+    let hasMatched = false;
     while (!done) {
       if (endNode && node.id === endNode.id) {
         done = true;
@@ -674,12 +728,17 @@ var BPTreeSync = class extends BPTree {
         const nValue = node.values[i];
         const keys = node.keys[i];
         if (comparator(nValue, value)) {
+          hasMatched = true;
           for (let j = 0, len2 = keys.length; j < len2; j++) {
             const key = keys[j];
             pairs.push([key, nValue]);
           }
+        } else if (earlyTerminate && hasMatched) {
+          done = true;
+          break;
         }
       }
+      if (done) break;
       if (!node.next) {
         done = true;
         break;
@@ -688,12 +747,12 @@ var BPTreeSync = class extends BPTree {
     }
     return new Map(pairs);
   }
-  getPairs(value, startNode, endNode, comparator, direction) {
+  getPairs(value, startNode, endNode, comparator, direction, earlyTerminate) {
     switch (direction) {
       case -1:
-        return this.getPairsRightToLeft(value, startNode, endNode, comparator);
+        return this.getPairsRightToLeft(value, startNode, endNode, comparator, earlyTerminate);
       case 1:
-        return this.getPairsLeftToRight(value, startNode, endNode, comparator);
+        return this.getPairsLeftToRight(value, startNode, endNode, comparator, earlyTerminate);
       default:
         throw new Error(`Direction must be -1 or 1. but got a ${direction}`);
     }
@@ -1042,6 +1101,30 @@ var BPTreeSync = class extends BPTree {
     }
     return node;
   }
+  /**
+   * Find the insertable node using primaryAsc comparison.
+   * This allows finding nodes by primary value only, ignoring unique identifiers.
+   */
+  insertableNodeByPrimary(value) {
+    let node = this.getNode(this.root.id);
+    while (!node.leaf) {
+      for (let i = 0, len = node.values.length; i < len; i++) {
+        const nValue = node.values[i];
+        const k = node.keys;
+        if (this.comparator.isPrimarySame(value, nValue)) {
+          node = this.getNode(k[i]);
+          break;
+        } else if (this.comparator.isPrimaryLower(value, nValue)) {
+          node = this.getNode(k[i]);
+          break;
+        } else if (i + 1 === node.values.length) {
+          node = this.getNode(k[i + 1]);
+          break;
+        }
+      }
+    }
+    return node;
+  }
   insertableEndNode(value, direction) {
     const insertableNode = this.insertableNode(value);
     let key;
@@ -1110,7 +1193,8 @@ var BPTreeSync = class extends BPTree {
       const endNode = this.verifierEndNode[key](value);
       const direction = this.verifierDirection[key];
       const comparator = this.verifierMap[key];
-      const pairs = this.getPairs(value, startNode, endNode, comparator, direction);
+      const earlyTerminate = this.verifierEarlyTerminate[key];
+      const pairs = this.getPairs(value, startNode, endNode, comparator, direction, earlyTerminate);
       if (!filterValues) {
         filterValues = new Set(pairs.keys());
       } else {
@@ -1135,7 +1219,8 @@ var BPTreeSync = class extends BPTree {
       const endNode = this.verifierEndNode[key](value);
       const direction = this.verifierDirection[key];
       const comparator = this.verifierMap[key];
-      const pairs = this.getPairs(value, startNode, endNode, comparator, direction);
+      const earlyTerminate = this.verifierEarlyTerminate[key];
+      const pairs = this.getPairs(value, startNode, endNode, comparator, direction, earlyTerminate);
       if (result === null) {
         result = pairs;
       } else {
@@ -1519,10 +1604,11 @@ var BPTreeAsync = class extends BPTree {
       this.lock.writeUnlock(lockId);
     });
   }
-  async getPairsRightToLeft(value, startNode, endNode, comparator) {
+  async getPairsRightToLeft(value, startNode, endNode, comparator, earlyTerminate) {
     const pairs = [];
     let node = startNode;
     let done = false;
+    let hasMatched = false;
     while (!done) {
       if (endNode && node.id === endNode.id) {
         done = true;
@@ -1533,12 +1619,17 @@ var BPTreeAsync = class extends BPTree {
         const nValue = node.values[i];
         const keys = node.keys[i];
         if (comparator(nValue, value)) {
+          hasMatched = true;
           let j = keys.length;
           while (j--) {
             pairs.push([keys[j], nValue]);
           }
+        } else if (earlyTerminate && hasMatched) {
+          done = true;
+          break;
         }
       }
+      if (done) break;
       if (!node.prev) {
         done = true;
         break;
@@ -1547,10 +1638,11 @@ var BPTreeAsync = class extends BPTree {
     }
     return new Map(pairs.reverse());
   }
-  async getPairsLeftToRight(value, startNode, endNode, comparator) {
+  async getPairsLeftToRight(value, startNode, endNode, comparator, earlyTerminate) {
     const pairs = [];
     let node = startNode;
     let done = false;
+    let hasMatched = false;
     while (!done) {
       if (endNode && node.id === endNode.id) {
         done = true;
@@ -1560,12 +1652,17 @@ var BPTreeAsync = class extends BPTree {
         const nValue = node.values[i];
         const keys = node.keys[i];
         if (comparator(nValue, value)) {
+          hasMatched = true;
           for (let j = 0, len2 = keys.length; j < len2; j++) {
             const key = keys[j];
             pairs.push([key, nValue]);
           }
+        } else if (earlyTerminate && hasMatched) {
+          done = true;
+          break;
         }
       }
+      if (done) break;
       if (!node.next) {
         done = true;
         break;
@@ -1574,12 +1671,12 @@ var BPTreeAsync = class extends BPTree {
     }
     return new Map(pairs);
   }
-  async getPairs(value, startNode, endNode, comparator, direction) {
+  async getPairs(value, startNode, endNode, comparator, direction, earlyTerminate) {
     switch (direction) {
       case -1:
-        return await this.getPairsRightToLeft(value, startNode, endNode, comparator);
+        return await this.getPairsRightToLeft(value, startNode, endNode, comparator, earlyTerminate);
       case 1:
-        return await this.getPairsLeftToRight(value, startNode, endNode, comparator);
+        return await this.getPairsLeftToRight(value, startNode, endNode, comparator, earlyTerminate);
       default:
         throw new Error(`Direction must be -1 or 1. but got a ${direction}`);
     }
@@ -1928,6 +2025,30 @@ var BPTreeAsync = class extends BPTree {
     }
     return node;
   }
+  /**
+   * Find the insertable node using primaryAsc comparison.
+   * This allows finding nodes by primary value only, ignoring unique identifiers.
+   */
+  async insertableNodeByPrimary(value) {
+    let node = await this.getNode(this.root.id);
+    while (!node.leaf) {
+      for (let i = 0, len = node.values.length; i < len; i++) {
+        const nValue = node.values[i];
+        const k = node.keys;
+        if (this.comparator.isPrimarySame(value, nValue)) {
+          node = await this.getNode(k[i]);
+          break;
+        } else if (this.comparator.isPrimaryLower(value, nValue)) {
+          node = await this.getNode(k[i]);
+          break;
+        } else if (i + 1 === node.values.length) {
+          node = await this.getNode(k[i + 1]);
+          break;
+        }
+      }
+    }
+    return node;
+  }
   async insertableEndNode(value, direction) {
     const insertableNode = await this.insertableNode(value);
     let key;
@@ -1997,7 +2118,8 @@ var BPTreeAsync = class extends BPTree {
         const endNode = await this.verifierEndNode[key](value);
         const direction = this.verifierDirection[key];
         const comparator = this.verifierMap[key];
-        const pairs = await this.getPairs(value, startNode, endNode, comparator, direction);
+        const earlyTerminate = this.verifierEarlyTerminate[key];
+        const pairs = await this.getPairs(value, startNode, endNode, comparator, direction, earlyTerminate);
         if (!filterValues) {
           filterValues = new Set(pairs.keys());
         } else {
@@ -2024,7 +2146,8 @@ var BPTreeAsync = class extends BPTree {
         const endNode = await this.verifierEndNode[key](value);
         const direction = this.verifierDirection[key];
         const comparator = this.verifierMap[key];
-        const pairs = await this.getPairs(value, startNode, endNode, comparator, direction);
+        const earlyTerminate = this.verifierEarlyTerminate[key];
+        const pairs = await this.getPairs(value, startNode, endNode, comparator, direction, earlyTerminate);
         if (result === null) {
           result = pairs;
         } else {
@@ -5422,24 +5545,13 @@ var TextCodec = class _TextCodec {
   }
 };
 
-// src/core/transaction/TxContext.ts
-var import_node_async_hooks = require("node:async_hooks");
-var storage = new import_node_async_hooks.AsyncLocalStorage();
-var TxContext = {
-  run: (tx, callback) => {
-    return storage.run(tx, callback);
-  },
-  get: () => {
-    return storage.getStore();
-  }
-};
-
 // src/core/RowIndexStrategy.ts
 var RowIdentifierStrategy = class extends SerializeStrategyAsync {
-  constructor(order, pfs) {
+  constructor(order, pfs, txContext) {
     super(order);
     this.order = order;
     this.pfs = pfs;
+    this.txContext = txContext;
     this.factory = new PageManagerFactory();
     this.indexPageManger = this.factory.getManagerFromType(PageManager.CONSTANT.PAGE_TYPE_INDEX);
     this.codec = new TextCodec();
@@ -5449,12 +5561,12 @@ var RowIdentifierStrategy = class extends SerializeStrategyAsync {
   indexPageManger;
   codec;
   async id(isLeaf) {
-    const tx = TxContext.get();
+    const tx = this.txContext.get();
     const pageId = await this.pfs.appendNewPage(PageManager.CONSTANT.PAGE_TYPE_INDEX, tx);
     return pageId.toString();
   }
   async read(id) {
-    const tx = TxContext.get();
+    const tx = this.txContext.get();
     const pageId = +id;
     const page = await this.pfs.get(pageId, tx);
     const indexId = this.indexPageManger.getIndexId(page);
@@ -5486,7 +5598,7 @@ var RowIdentifierStrategy = class extends SerializeStrategyAsync {
     return res;
   }
   async write(id, node) {
-    const tx = TxContext.get();
+    const tx = this.txContext.get();
     const pageId = +id;
     const page = await this.pfs.get(pageId, tx);
     if (node.leaf) {
@@ -5521,7 +5633,7 @@ var RowIdentifierStrategy = class extends SerializeStrategyAsync {
     await this.pfs.setPage(pageId, page, tx);
   }
   async delete(id) {
-    const tx = TxContext.get();
+    const tx = this.txContext.get();
     const manager = this.factory.getManagerFromType(PageManager.CONSTANT.PAGE_TYPE_INDEX);
     let pageId = +id;
     while (true) {
@@ -5535,7 +5647,7 @@ var RowIdentifierStrategy = class extends SerializeStrategyAsync {
     }
   }
   async readHead() {
-    const tx = TxContext.get();
+    const tx = this.txContext.get();
     const metadataPage = await this.pfs.getMetadata(tx);
     const manager = this.factory.getManager(metadataPage);
     const rootIndexPageId = manager.getRootIndexPageId(metadataPage);
@@ -5549,7 +5661,7 @@ var RowIdentifierStrategy = class extends SerializeStrategyAsync {
     };
   }
   async writeHead(head) {
-    const tx = TxContext.get();
+    const tx = this.txContext.get();
     const { root, order } = head;
     if (root === null) {
       throw new Error("");
@@ -5617,8 +5729,9 @@ var KeyManager = class {
 
 // src/core/RowTableEngine.ts
 var RowTableEngine = class {
-  constructor(pfs, options) {
+  constructor(pfs, txContext, options) {
     this.pfs = pfs;
+    this.txContext = txContext;
     this.options = options;
     this.factory = new PageManagerFactory();
     this.metadataPageManager = this.factory.getManagerFromType(MetadataPageManager.CONSTANT.PAGE_TYPE_METADATA);
@@ -5631,7 +5744,7 @@ var RowTableEngine = class {
     this.maxBodySize = this.pfs.pageSize - DataPageManager.CONSTANT.SIZE_PAGE_HEADER;
     this.order = this.getOptimalOrder(pfs.pageSize, IndexPageManager.CONSTANT.SIZE_KEY, IndexPageManager.CONSTANT.SIZE_VALUE);
     this.bptree = new BPTreeAsync(
-      new RowIdentifierStrategy(this.order, pfs),
+      new RowIdentifierStrategy(this.order, pfs, txContext),
       new NumericComparator(),
       {
         capacity: this.options.pageCacheCapacity
@@ -6061,7 +6174,8 @@ var Transaction = class {
    * @param vfs VFS instance
    * @param lockManager LockManager instance
    */
-  constructor(id, vfs, lockManager) {
+  constructor(id, context, vfs, lockManager) {
+    this.context = context;
     this.vfs = vfs;
     this.lockManager = lockManager;
     this.id = id;
@@ -6170,7 +6284,7 @@ var Transaction = class {
   async commit() {
     await this.vfs.prepareCommit(this);
     await this.vfs.finalizeCommit(this);
-    await TxContext.run(this, async () => {
+    await this.context.run(this, async () => {
       for (const hook of this.commitHooks) {
         await hook();
       }
@@ -6211,6 +6325,18 @@ var Transaction = class {
   }
 };
 
+// src/core/transaction/TxContext.ts
+var import_node_async_hooks = require("node:async_hooks");
+var TransactionContext = class {
+  storage = new import_node_async_hooks.AsyncLocalStorage();
+  run(tx, callback) {
+    return this.storage.run(tx, callback);
+  }
+  get() {
+    return this.storage.getStore();
+  }
+};
+
 // src/core/DataplyAPI.ts
 var DataplyAPI = class {
   constructor(file, options) {
@@ -6226,8 +6352,9 @@ var DataplyAPI = class {
       this.options.wal
     );
     this.textCodec = new TextCodec();
+    this.txContext = new TransactionContext();
     this.lockManager = new LockManager();
-    this.rowTableEngine = new RowTableEngine(this.pfs, this.options);
+    this.rowTableEngine = new RowTableEngine(this.pfs, this.txContext, this.options);
     this.initialized = false;
     this.txIdCounter = 0;
   }
@@ -6247,6 +6374,8 @@ var DataplyAPI = class {
   lockManager;
   /** Text codec. Used for encoding and decoding text data */
   textCodec;
+  /** Transaction context */
+  txContext;
   /** Hook */
   hook;
   /** Whether the database was initialized via `init()` */
@@ -6389,7 +6518,12 @@ var DataplyAPI = class {
    * @returns Transaction object
    */
   createTransaction() {
-    return new Transaction(++this.txIdCounter, this.pfs.vfsInstance, this.lockManager);
+    return new Transaction(
+      ++this.txIdCounter,
+      this.txContext,
+      this.pfs.vfsInstance,
+      this.lockManager
+    );
   }
   /**
    * Runs a callback function within a transaction context.
@@ -6405,7 +6539,7 @@ var DataplyAPI = class {
     if (!tx) {
       tx = this.createTransaction();
     }
-    const [error, result] = await catchPromise(TxContext.run(tx, () => callback(tx)));
+    const [error, result] = await catchPromise(this.txContext.run(tx, () => callback(tx)));
     if (error) {
       if (isInternalTx) {
         await tx.rollback();

package/dist/types/core/DataplyAPI.d.ts

@@ -5,6 +5,7 @@ import { RowTableEngine } from './RowTableEngine';
 import { TextCodec } from '../utils/TextCodec';
 import { LockManager } from './transaction/LockManager';
 import { Transaction } from './transaction/Transaction';
+import { TransactionContext } from './transaction/TxContext';
 interface DataplyAPIAsyncHook {
     init: (tx: Transaction, isNewlyCreated: boolean) => Promise<Transaction>;
     close: () => Promise<void>;
@@ -30,6 +31,8 @@ export declare class DataplyAPI {
     protected readonly lockManager: LockManager;
     /** Text codec. Used for encoding and decoding text data */
     protected readonly textCodec: TextCodec;
+    /** Transaction context */
+    protected readonly txContext: TransactionContext;
     /** Hook */
     protected readonly hook: IHookall<DataplyAPIAsyncHook>;
     /** Whether the database was initialized via `init()` */

package/dist/types/core/RowIndexStrategy.d.ts

@@ -3,14 +3,16 @@ import { SerializeStrategyAsync } from 'serializable-bptree';
 import { PageFileSystem } from './PageFileSystem';
 import { IndexPageManager, PageManagerFactory } from './Page';
 import { TextCodec } from '../utils/TextCodec';
+import { TransactionContext } from './transaction/TxContext';
 export declare class RowIdentifierStrategy extends SerializeStrategyAsync<number, number> {
     readonly order: number;
     protected readonly pfs: PageFileSystem;
+    protected readonly txContext: TransactionContext;
     protected rootPageId: number;
     protected factory: PageManagerFactory;
     protected indexPageManger: IndexPageManager;
     protected codec: TextCodec;
-    constructor(order: number, pfs: PageFileSystem);
+    constructor(order: number, pfs: PageFileSystem, txContext: TransactionContext);
     id(isLeaf: boolean): Promise<string>;
     read(id: string): Promise<BPTreeNode<number, number>>;
     write(id: string, node: BPTreeNode<number, number>): Promise<void>;

package/dist/types/core/RowTableEngine.d.ts

@@ -5,8 +5,10 @@ import { Row } from './Row';
 import { KeyManager } from './KeyManager';
 import { PageManagerFactory } from './Page';
 import { Transaction } from './transaction/Transaction';
+import { TransactionContext } from './transaction/TxContext';
 export declare class RowTableEngine {
     protected readonly pfs: PageFileSystem;
+    protected readonly txContext: TransactionContext;
     protected readonly options: Required<DataplyOptions>;
     protected readonly bptree: BPTreeAsync<number, number>;
     protected readonly order: number;
@@ -20,7 +22,7 @@ export declare class RowTableEngine {
     private readonly ridBuffer;
     private readonly pageIdBuffer;
     private initialized;
-    constructor(pfs: PageFileSystem, options: Required<DataplyOptions>);
+    constructor(pfs: PageFileSystem, txContext: TransactionContext, options: Required<DataplyOptions>);
     /**
      * Initializes the B+ Tree.
      */

package/dist/types/core/transaction/Transaction.d.ts

@@ -1,12 +1,14 @@
 import { LockManager } from './LockManager';
 import { VirtualFileSystem } from '../VirtualFileSystem';
+import { TransactionContext } from './TxContext';
 /**
  * Transaction class.
  * Manages the lifecycle and resources of a database transaction.
  */
 export declare class Transaction {
-    private vfs;
-    private lockManager;
+    readonly context: TransactionContext;
+    private readonly vfs;
+    private readonly lockManager;
     /** Transaction ID */
     readonly id: number;
     /** List of held lock IDs (LOCK_ID) */
@@ -26,7 +28,7 @@ export declare class Transaction {
      * @param vfs VFS instance
      * @param lockManager LockManager instance
      */
-    constructor(id: number, vfs: VirtualFileSystem, lockManager: LockManager);
+    constructor(id: number, context: TransactionContext, vfs: VirtualFileSystem, lockManager: LockManager);
     /**
      * Registers a commit hook.
      * @param hook Function to execute

package/dist/types/core/transaction/TxContext.d.ts

@@ -1,5 +1,6 @@
 import { Transaction } from './Transaction';
-export declare const TxContext: {
-    run: <T>(tx: Transaction, callback: () => T) => T;
-    get: () => Transaction | undefined;
-};
+export declare class TransactionContext {
+    private readonly storage;
+    run<T>(tx: Transaction, callback: () => T): T;
+    get(): Transaction | undefined;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dataply",
-  "version": "0.0.9",
+  "version": "0.0.11",
   "description": "A lightweight storage engine for Node.js with support for MVCC, WAL.",
   "license": "MIT",
   "author": "izure <admin@izure.org>",
@@ -47,6 +47,6 @@
     "cache-entanglement": "^1.7.1",
     "hookall": "^2.2.0",
     "ryoiki": "^1.2.0",
-    "serializable-bptree": "^6.0.2"
+    "serializable-bptree": "^6.1.0"
   }
 }

package/readme.md

@@ -15,6 +15,7 @@
 - **📝 WAL (Write-Ahead Logging)**: Ensures data integrity and provides recovery capabilities in case of system failures.
 - **💼 Transaction Mechanism**: Supports Commit and Rollback for atomic operations.
 - **📦 Page-Based Storage**: Efficient page caching and disk I/O optimization through Virtual File System (VFS).
+- **📉 Bitmap Space Optimization**: Uses bitmapped management to efficiently track page usage and maximize disk space utilization.
 - **⌨️ TypeScript Support**: Provides comprehensive type definitions for all APIs.
 
 ## Installation
@@ -224,6 +225,7 @@ graph TD
 - **Fixed-size Pages**: All data is managed in fixed-size units (default 8KB) called pages.
 - **VFS Cache**: Minimizes disk I/O by caching frequently accessed pages in memory.
 - **Dirty Page Tracking**: Tracks modified pages (Dirty) to synchronize them with disk efficiently only at the time of commit.
+- **Bitmap Management**: Efficiently tracks the allocation and deallocation of pages using a bitmap structure, facilitating fast space reclamation and reuse. For more details on this mechanism, see [Page Reclamation and Reuse Guide](docs/page_reclamation.md).
 - **Detailed Structure**: For technical details on the physical layout, see [structure.md](docs/structure.md).
 
 #### Page & Row Layout