dataply 0.0.7 → 0.0.9

package/dist/cjs/index.js

@@ -32,21 +32,30 @@ var src_exports = {};
 __export(src_exports, {
   BPTreeAsync: () => BPTreeAsync,
   BPTreeSync: () => BPTreeSync,
+  BitmapPageManager: () => BitmapPageManager,
   CacheEntanglementAsync: () => CacheEntanglementAsync2,
   CacheEntanglementSync: () => CacheEntanglementSync2,
+  DataPageManager: () => DataPageManager,
   Dataply: () => Dataply,
   DataplyAPI: () => DataplyAPI,
+  EmptyPageManager: () => EmptyPageManager,
   GlobalTransaction: () => GlobalTransaction,
   InMemoryStoreStrategyAsync: () => InMemoryStoreStrategyAsync,
   InMemoryStoreStrategySync: () => InMemoryStoreStrategySync,
+  IndexPageManager: () => IndexPageManager,
   InvertedWeakMap: () => InvertedWeakMap,
   LRUMap: () => LRUMap2,
+  MetadataPageManager: () => MetadataPageManager,
   NumericComparator: () => NumericComparator,
+  OverflowPageManager: () => OverflowPageManager,
+  PageManager: () => PageManager,
+  PageManagerFactory: () => PageManagerFactory,
   Ryoiki: () => Ryoiki2,
   SerializeStrategyAsync: () => SerializeStrategyAsync,
   SerializeStrategySync: () => SerializeStrategySync,
   StringComparator: () => StringComparator,
   Transaction: () => Transaction,
+  UnknownPageManager: () => UnknownPageManager,
   ValueComparator: () => ValueComparator
 });
 module.exports = __toCommonJS(src_exports);
@@ -2945,323 +2954,6 @@ var InvertedWeakMap = class {
   }
 };
 
-// src/core/DataplyAPI.ts
-var import_node_fs3 = __toESM(require("node:fs"));
-
-// node_modules/hookall/dist/esm/index.mjs
-var HookallStore = class extends WeakMap {
-  ensure(obj, key) {
-    if (!this.has(obj)) {
-      const scope2 = {};
-      this.set(obj, scope2);
-    }
-    const scope = this.get(obj);
-    if (!Object.prototype.hasOwnProperty.call(scope, key)) {
-      scope[key] = /* @__PURE__ */ new Map();
-    }
-    return scope[key];
-  }
-};
-var Hookall = class _Hookall {
-  static Global = {};
-  static _Store = new HookallStore();
-  beforeHooks;
-  afterHooks;
-  /**
-   * Create hook system. you can pass a target object or undefined.
-   * If you pass a object, the hook system will be work for object locally. You're going to want this kind of usage in general.
-   * If not specified, will be work for global. This is useful when you want to share your work with multiple files.
-   * @param target The object to work with locally. If not specified, will be work for global.
-   */
-  constructor(target) {
-    this.beforeHooks = _Hookall._Store.ensure(target, "before");
-    this.afterHooks = _Hookall._Store.ensure(target, "after");
-  }
-  _ensureCommand(hooks, command) {
-    if (!hooks.has(command)) {
-      hooks.set(command, []);
-    }
-    return hooks.get(command);
-  }
-  _createWrapper(command, callback, repeat) {
-    return {
-      callback,
-      command,
-      repeat
-    };
-  }
-  _on(hooks, command, callback, repeat) {
-    const wrappers = this._ensureCommand(hooks, command);
-    const wrapper = this._createWrapper(command, callback, repeat);
-    wrappers.unshift(wrapper);
-  }
-  /**
-   * You register a preprocessing function, which is called before the callback function of the `trigger` method.
-   * The value returned by this function is passed as a parameter to the `trigger` method's callback function.
-   * If you register multiple preprocessing functions, they are executed in order, with each function receiving the value returned by the previous one as a parameter.
-   * @param command Command to work.
-   * @param callback Preprocessing function to register.
-   */
-  onBefore(command, callback) {
-    this._on(this.beforeHooks, command, callback, -1);
-    return this;
-  }
-  /**
-   * Similar to the `onBefore` method, but it only runs once.
-   * For more details, please refer to the `onBefore` method.
-   * @param command Command to work.
-   * @param callback Preprocessing function to register.
-   */
-  onceBefore(command, callback) {
-    this._on(this.beforeHooks, command, callback, 1);
-    return this;
-  }
-  /**
-   * You register a post-processing function which is called after the callback function of the `trigger` method finishes.
-   * This function receives the value returned by the `trigger` method's callback function as a parameter.
-   * If you register multiple post-processing functions, they are executed in order, with each function receiving the value returned by the previous one as a parameter.
-   * @param command Command to work.
-   * @param callback Post-preprocessing function to register.
-   */
-  onAfter(command, callback) {
-    this._on(this.afterHooks, command, callback, -1);
-    return this;
-  }
-  /**
-   * Similar to the `onAfter` method, but it only runs once.
-   * For more details, please refer to the `onAfter` method.
-   * @param command Command to work.
-   * @param callback Post-preprocessing function to register.
-   */
-  onceAfter(command, callback) {
-    this._on(this.afterHooks, command, callback, 1);
-    return this;
-  }
-  _off(hooks, command, callback) {
-    const wrappers = this._ensureCommand(hooks, command);
-    if (callback) {
-      const i = wrappers.findIndex((wrapper) => wrapper.callback === callback);
-      if (i !== -1) {
-        wrappers.splice(i, 1);
-      }
-    } else {
-      wrappers.length = 0;
-    }
-    return this;
-  }
-  /**
-   * You remove the preprocessing functions registered with `onBefore` or `onceBefore` methods.
-   * If you don't specify a callback parameter, it removes all preprocessing functions registered for that command.
-   * @param command Commands with preprocessing functions to be deleted.
-   * @param callback Preprocessing function to be deleted.
-   */
-  offBefore(command, callback) {
-    this._off(this.beforeHooks, command, callback);
-    return this;
-  }
-  /**
-   * You remove the post-preprocessing functions registered with `onAfter` or `onceAfter` methods.
-   * If you don't specify a callback parameter, it removes all post-preprocessing functions registered for that command.
-   * @param command Commands with post-preprocessing functions to be deleted.
-   * @param callback post-Preprocessing function to be deleted.
-   */
-  offAfter(command, callback) {
-    this._off(this.afterHooks, command, callback);
-    return this;
-  }
-  async _hookWith(hooks, command, value, ...params) {
-    let wrappers = this._ensureCommand(hooks, command);
-    let i = wrappers.length;
-    while (i--) {
-      const wrapper = wrappers[i];
-      value = await wrapper.callback(value, ...params);
-      wrapper.repeat -= 1;
-      if (wrapper.repeat === 0) {
-        this._off(hooks, command, wrapper.callback);
-      }
-    }
-    return value;
-  }
-  /**
-   * You execute the callback function provided as a parameter. This callback function receives the 'initialValue' parameter.
-   * 
-   * If preprocessing functions are registered, they run first, and the value returned by the preprocessing functions becomes the 'initialValue' parameter.
-   * After the callback function finishes, post-processing functions are called.
-   * These post-processing functions receive the value returned by the callback function as a parameter and run sequentially.
-   * 
-   * The final value returned becomes the result of the `trigger` method.
-   * @param command Command to work.
-   * @param initialValue Initial value to be passed to the callback function.
-   * @param callback The callback function to be executed.
-   */
-  async trigger(command, initialValue, callback, ...params) {
-    let value;
-    value = await this._hookWith(this.beforeHooks, command, initialValue, ...params);
-    value = await callback(value, ...params);
-    value = await this._hookWith(this.afterHooks, command, value, ...params);
-    return value;
-  }
-};
-function useHookall(target = Hookall.Global) {
-  return new Hookall(target);
-}
-var HookallStore2 = class extends WeakMap {
-  ensure(obj, key) {
-    if (!this.has(obj)) {
-      const scope2 = {};
-      this.set(obj, scope2);
-    }
-    const scope = this.get(obj);
-    if (!Object.prototype.hasOwnProperty.call(scope, key)) {
-      scope[key] = /* @__PURE__ */ new Map();
-    }
-    return scope[key];
-  }
-};
-var HookallSync = class _HookallSync {
-  static Global = {};
-  static _Store = new HookallStore2();
-  beforeHooks;
-  afterHooks;
-  /**
-   * Create hook system. you can pass a target object or undefined.
-   * If you pass a object, the hook system will be work for object locally. You're going to want this kind of usage in general.
-   * If not specified, will be work for global. This is useful when you want to share your work with multiple files.
-   * @param target The object to work with locally. If not specified, will be work for global.
-   */
-  constructor(target) {
-    this.beforeHooks = _HookallSync._Store.ensure(target, "before");
-    this.afterHooks = _HookallSync._Store.ensure(target, "after");
-  }
-  _ensureCommand(hooks, command) {
-    if (!hooks.has(command)) {
-      hooks.set(command, []);
-    }
-    return hooks.get(command);
-  }
-  _createWrapper(command, callback, repeat) {
-    return {
-      callback,
-      command,
-      repeat
-    };
-  }
-  _on(hooks, command, callback, repeat) {
-    const wrappers = this._ensureCommand(hooks, command);
-    const wrapper = this._createWrapper(command, callback, repeat);
-    wrappers.unshift(wrapper);
-  }
-  /**
-   * You register a preprocessing function, which is called before the callback function of the `trigger` method.
-   * The value returned by this function is passed as a parameter to the `trigger` method's callback function.
-   * If you register multiple preprocessing functions, they are executed in order, with each function receiving the value returned by the previous one as a parameter.
-   * @param command Command to work.
-   * @param callback Preprocessing function to register.
-   */
-  onBefore(command, callback) {
-    this._on(this.beforeHooks, command, callback, -1);
-    return this;
-  }
-  /**
-   * Similar to the `onBefore` method, but it only runs once.
-   * For more details, please refer to the `onBefore` method.
-   * @param command Command to work.
-   * @param callback Preprocessing function to register.
-   */
-  onceBefore(command, callback) {
-    this._on(this.beforeHooks, command, callback, 1);
-    return this;
-  }
-  /**
-   * You register a post-processing function which is called after the callback function of the `trigger` method finishes.
-   * This function receives the value returned by the `trigger` method's callback function as a parameter.
-   * If you register multiple post-processing functions, they are executed in order, with each function receiving the value returned by the previous one as a parameter.
-   * @param command Command to work.
-   * @param callback Post-preprocessing function to register.
-   */
-  onAfter(command, callback) {
-    this._on(this.afterHooks, command, callback, -1);
-    return this;
-  }
-  /**
-   * Similar to the `onAfter` method, but it only runs once.
-   * For more details, please refer to the `onAfter` method.
-   * @param command Command to work.
-   * @param callback Post-preprocessing function to register.
-   */
-  onceAfter(command, callback) {
-    this._on(this.afterHooks, command, callback, 1);
-    return this;
-  }
-  _off(hooks, command, callback) {
-    const wrappers = this._ensureCommand(hooks, command);
-    if (callback) {
-      const i = wrappers.findIndex((wrapper) => wrapper.callback === callback);
-      if (i !== -1) {
-        wrappers.splice(i, 1);
-      }
-    } else {
-      wrappers.length = 0;
-    }
-    return this;
-  }
-  /**
-   * You remove the preprocessing functions registered with `onBefore` or `onceBefore` methods.
-   * If you don't specify a callback parameter, it removes all preprocessing functions registered for that command.
-   * @param command Commands with preprocessing functions to be deleted.
-   * @param callback Preprocessing function to be deleted.
-   */
-  offBefore(command, callback) {
-    this._off(this.beforeHooks, command, callback);
-    return this;
-  }
-  /**
-   * You remove the post-preprocessing functions registered with `onAfter` or `onceAfter` methods.
-   * If you don't specify a callback parameter, it removes all post-preprocessing functions registered for that command.
-   * @param command Commands with post-preprocessing functions to be deleted.
-   * @param callback post-Preprocessing function to be deleted.
-   */
-  offAfter(command, callback) {
-    this._off(this.afterHooks, command, callback);
-    return this;
-  }
-  _hookWith(hooks, command, value, ...params) {
-    let wrappers = this._ensureCommand(hooks, command);
-    let i = wrappers.length;
-    while (i--) {
-      const wrapper = wrappers[i];
-      value = wrapper.callback(value, ...params);
-      wrapper.repeat -= 1;
-      if (wrapper.repeat === 0) {
-        this._off(hooks, command, wrapper.callback);
-      }
-    }
-    return value;
-  }
-  /**
-   * You execute the callback function provided as a parameter. This callback function receives the 'initialValue' parameter.
-   * 
-   * If preprocessing functions are registered, they run first, and the value returned by the preprocessing functions becomes the 'initialValue' parameter.
-   * After the callback function finishes, post-processing functions are called.
-   * These post-processing functions receive the value returned by the callback function as a parameter and run sequentially.
-   * 
-   * The final value returned becomes the result of the `trigger` method.
-   * @param command Command to work.
-   * @param initialValue Initial value to be passed to the callback function.
-   * @param callback The callback function to be executed.
-   */
-  trigger(command, initialValue, callback, ...params) {
-    let value;
-    value = this._hookWith(this.beforeHooks, command, initialValue, ...params);
-    value = callback(value, ...params);
-    value = this._hookWith(this.afterHooks, command, value, ...params);
-    return value;
-  }
-};
-function useHookallSync(target = HookallSync.Global) {
-  return new HookallSync(target);
-}
-
 // src/utils/numberToBytes.ts
 function numberToBytes(value, buffer, offset = 0, length = buffer.length) {
   if (length === 4) {
@@ -3559,1065 +3251,1379 @@ var PageManager = class _PageManager {
     );
   }
   /**
-   * Sets the page type.
+   * Sets the page type.
+   * @param page Page data
+   * @param pageType Page type
+   */
+  setPageType(page, pageType) {
+    numberToBytes(
+      pageType,
+      page,
+      _PageManager.CONSTANT.OFFSET_PAGE_TYPE,
+      _PageManager.CONSTANT.SIZE_PAGE_TYPE
+    );
+  }
+  /**
+   * Sets the page ID.
+   * @param page Page data
+   * @param pageId Page ID
+   */
+  setPageId(page, pageId) {
+    numberToBytes(
+      pageId,
+      page,
+      _PageManager.CONSTANT.OFFSET_PAGE_ID,
+      _PageManager.CONSTANT.SIZE_PAGE_ID
+    );
+  }
+  /**
+   * Sets the ID of the next connected page.
+   * @param page Page data
+   * @param nextPageId Next connected page ID
+   */
+  setNextPageId(page, nextPageId) {
+    numberToBytes(
+      nextPageId,
+      page,
+      _PageManager.CONSTANT.OFFSET_NEXT_PAGE_ID,
+      _PageManager.CONSTANT.SIZE_NEXT_PAGE_ID
+    );
+  }
+  /**
+   * Sets the remaining capacity of the page.
+   * @param page Page data
+   * @param remainingCapacity Remaining capacity
+   */
+  setRemainingCapacity(page, remainingCapacity) {
+    numberToBytes(
+      remainingCapacity,
+      page,
+      _PageManager.CONSTANT.OFFSET_REMAINING_CAPACITY,
+      _PageManager.CONSTANT.SIZE_REMAINING_CAPACITY
+    );
+  }
+  /**
+   * Sets the checksum of the page.
+   * @param page Page data
+   * @param checksum Checksum
+   */
+  setChecksum(page, checksum) {
+    numberToBytes(
+      checksum,
+      page,
+      _PageManager.CONSTANT.OFFSET_CHECKSUM,
+      _PageManager.CONSTANT.SIZE_CHECKSUM
+    );
+  }
+  /**
+   * Updates the checksum of the page.
+   * Calculates the checksum of the page body (excluding the header) and sets it in the header.
+   * @param page Page data
+   */
+  updateChecksum(page) {
+    const body = this.getBody(page);
+    const checksum = crc32(body);
+    this.setChecksum(page, checksum);
+  }
+  /**
+   * Verifies the checksum of the page.
+   * Calculates the checksum of the page body and compares it with the checksum stored in the header.
+   * @param page Page data
+   * @returns boolean indicating if the checksum is valid
+   */
+  verifyChecksum(page) {
+    const body = this.getBody(page);
+    const checksum = crc32(body);
+    const storedChecksum = this.getChecksum(page);
+    return checksum === storedChecksum;
+  }
+  /**
+   * Sets the page header.
+   * @param page Page data
+   * @param header Page header
+   */
+  setHeader(page, header) {
+    page.set(header);
+  }
+  /**
+   * Sets the page body.
+   * @param page Page data
+   * @param body Page body
+   */
+  setBody(page, body) {
+    page.set(body, _PageManager.CONSTANT.SIZE_PAGE_HEADER);
+  }
+  /**
+   * Initializes the page.
+   * @param page Page data
+   * @param pageType Page type
+   * @param pageId Page ID
+   * @param nextPageId Next connected page ID
+   * @param remainingCapacity Remaining capacity
+   */
+  initial(page, pageType, pageId, nextPageId, remainingCapacity) {
+    this.setPageType(page, pageType);
+    this.setPageId(page, pageId);
+    this.setNextPageId(page, nextPageId);
+    this.setRemainingCapacity(page, remainingCapacity);
+  }
+  /**
+   * Returns the body of the page.
+   * @param page Page data
+   * @returns Page body
+   */
+  getBody(page) {
+    return page.subarray(_PageManager.CONSTANT.SIZE_PAGE_HEADER);
+  }
+  /**
+   * Creates a new page.
+   * @param pageSize Page size
+   * @param pageId Page ID
+   * @returns Created page data
+   */
+  create(pageSize, pageId) {
+    const page = new Uint8Array(pageSize);
+    const headerSize = _PageManager.CONSTANT.SIZE_PAGE_HEADER;
+    const remainingCapacity = pageSize - headerSize;
+    this.initial(
+      page,
+      this.pageType,
+      pageId,
+      -1,
+      remainingCapacity
+    );
+    return page;
+  }
+};
+var EmptyPageManager = class _EmptyPageManager extends PageManager {
+  get pageType() {
+    return PageManager.CONSTANT.PAGE_TYPE_EMPTY;
+  }
+  /**
+   * Checks if the page type is `EmptyPage`.
+   * @param page Page data
+   * @returns boolean indicating if the page type is `EmptyPage`
+   */
+  static IsEmptyPage(page) {
+    return PageManager.GetPageType(page) === PageManager.CONSTANT.PAGE_TYPE_EMPTY;
+  }
+  /**
+   * Checks if the page type is `EmptyPage`.
+   * @param page Page data
+   * @returns boolean indicating if the page type is `EmptyPage`
+   */
+  isEmptyPage(page) {
+    return _EmptyPageManager.IsEmptyPage(page);
+  }
+};
+var DataPageManager = class _DataPageManager extends PageManager {
+  get pageType() {
+    return PageManager.CONSTANT.PAGE_TYPE_DATA;
+  }
+  row = new Row();
+  /**
+   * Checks if the page type is `DataPage`.
+   * @param page Page data
+   * @returns boolean indicating if the page type is `DataPage`
+   */
+  static IsDataPage(page) {
+    return PageManager.GetPageType(page) === PageManager.CONSTANT.PAGE_TYPE_DATA;
+  }
+  /**
+   * Checks if the page type is `DataPage`.
+   * @param page Page data
+   * @returns boolean indicating if the page type is `DataPage`
+   */
+  isDataPage(page) {
+    return _DataPageManager.IsDataPage(page);
+  }
+  /**
+   * Returns the offset of a row within the page.
+   * @param page Page data
+   * @param slotIndex Slot index
+   * @returns Row offset within the page
+   */
+  getRowOffset(page, slotIndex) {
+    return bytesToNumber(
+      page,
+      page.length - PageManager.CONSTANT.SIZE_SLOT_OFFSET - slotIndex * PageManager.CONSTANT.SIZE_SLOT_OFFSET,
+      PageManager.CONSTANT.SIZE_SLOT_OFFSET
+    );
+  }
+  /**
+   * Returns the row from the page.
+   * @param page Page data
+   * @param slotIndex Slot index
+   * @returns Row data within the page
+   */
+  getRow(page, slotIndex) {
+    const offset = this.getRowOffset(page, slotIndex);
+    const headerSize = Row.CONSTANT.SIZE_HEADER;
+    const bodySize = this.row.getBodySize(page.subarray(offset));
+    const row = page.subarray(offset, offset + headerSize + bodySize);
+    return row;
+  }
+  /**
+   * Returns the number of rows inserted into the page.
    * @param page Page data
-   * @param pageType Page type
+   * @returns Number of rows inserted
    */
-  setPageType(page, pageType) {
-    numberToBytes(
-      pageType,
+  getInsertedRowCount(page) {
+    return bytesToNumber(
       page,
-      _PageManager.CONSTANT.OFFSET_PAGE_TYPE,
-      _PageManager.CONSTANT.SIZE_PAGE_TYPE
+      PageManager.CONSTANT.OFFSET_INSERTED_ROW_COUNT,
+      PageManager.CONSTANT.SIZE_INSERTED_ROW_COUNT
     );
   }
   /**
-   * Sets the page ID.
+   * Sets the offset of a row within the page.
    * @param page Page data
-   * @param pageId Page ID
+   * @param slotIndex Slot index
+   * @param offset Row offset within the page
    */
-  setPageId(page, pageId) {
+  setRowOffset(page, slotIndex, offset) {
     numberToBytes(
-      pageId,
+      offset,
       page,
-      _PageManager.CONSTANT.OFFSET_PAGE_ID,
-      _PageManager.CONSTANT.SIZE_PAGE_ID
+      page.length - PageManager.CONSTANT.SIZE_SLOT_OFFSET - slotIndex * PageManager.CONSTANT.SIZE_SLOT_OFFSET,
+      PageManager.CONSTANT.SIZE_SLOT_OFFSET
     );
   }
   /**
-   * Sets the ID of the next connected page.
+   * Sets the number of rows inserted into the page.
    * @param page Page data
-   * @param nextPageId Next connected page ID
+   * @param insertedRowCount Number of rows inserted
    */
-  setNextPageId(page, nextPageId) {
+  setInsertedRowCount(page, insertedRowCount) {
     numberToBytes(
-      nextPageId,
+      insertedRowCount,
       page,
-      _PageManager.CONSTANT.OFFSET_NEXT_PAGE_ID,
-      _PageManager.CONSTANT.SIZE_NEXT_PAGE_ID
+      PageManager.CONSTANT.OFFSET_INSERTED_ROW_COUNT,
+      PageManager.CONSTANT.SIZE_INSERTED_ROW_COUNT
     );
   }
   /**
-   * Sets the remaining capacity of the page.
+   * Calculates if there is space for a row in the page and determines insertability.
+   * If insertable, returns the slot index to be inserted.
+   * If not, returns -1.
    * @param page Page data
-   * @param remainingCapacity Remaining capacity
+   * @param row Row data
+   * @returns Slot index for the row
    */
-  setRemainingCapacity(page, remainingCapacity) {
-    numberToBytes(
-      remainingCapacity,
-      page,
-      _PageManager.CONSTANT.OFFSET_REMAINING_CAPACITY,
-      _PageManager.CONSTANT.SIZE_REMAINING_CAPACITY
-    );
+  getNextSlotIndex(page, row) {
+    const slotOffsetSize = PageManager.CONSTANT.SIZE_SLOT_OFFSET;
+    const remainingCapacity = this.getRemainingCapacity(page);
+    const totalSize = row.length + slotOffsetSize;
+    return remainingCapacity >= totalSize ? this.getInsertedRowCount(page) : -1;
   }
   /**
-   * Sets the checksum of the page.
+   * Returns the position for the next row to be inserted.
    * @param page Page data
-   * @param checksum Checksum
+   * @returns Next insert position
    */
-  setChecksum(page, checksum) {
-    numberToBytes(
-      checksum,
-      page,
-      _PageManager.CONSTANT.OFFSET_CHECKSUM,
-      _PageManager.CONSTANT.SIZE_CHECKSUM
-    );
+  getNextInsertPosition(page) {
+    const insertedRowCount = this.getInsertedRowCount(page);
+    if (insertedRowCount === 0) {
+      return _DataPageManager.CONSTANT.SIZE_PAGE_HEADER;
+    }
+    const lastRowIndex = insertedRowCount - 1;
+    const lastRowOffset = this.getRowOffset(page, lastRowIndex);
+    const lastRow = this.getRow(page, lastRowIndex);
+    return lastRowOffset + lastRow.length;
   }
   /**
-   * Updates the checksum of the page.
-   * Calculates the checksum of the page body (excluding the header) and sets it in the header.
+   * Inserts a row into the page. `getNextSlotIndex` should be called beforehand to verify availability.
    * @param page Page data
+   * @param row Row data
    */
-  updateChecksum(page) {
-    const body = this.getBody(page);
-    const checksum = crc32(body);
-    this.setChecksum(page, checksum);
+  insert(page, row) {
+    const slotOffsetSize = PageManager.CONSTANT.SIZE_SLOT_OFFSET;
+    const remainingCapacity = this.getRemainingCapacity(page);
+    const totalSize = row.length + slotOffsetSize;
+    if (remainingCapacity < totalSize) {
+      throw new Error("Not enough space to insert row");
+    }
+    const insertedRowCount = this.getInsertedRowCount(page);
+    const offset = this.getNextInsertPosition(page);
+    page.set(row, offset);
+    this.setRowOffset(page, insertedRowCount, offset);
+    this.setInsertedRowCount(page, insertedRowCount + 1);
+    this.setRemainingCapacity(page, remainingCapacity - totalSize);
+  }
+};
+var IndexPageManager = class _IndexPageManager extends PageManager {
+  get pageType() {
+    return PageManager.CONSTANT.PAGE_TYPE_INDEX;
   }
+  static CONSTANT = {
+    ...PageManager.CONSTANT,
+    OFFSET_INDEX_ID: 100,
+    OFFSET_PARENT_INDEX_ID: 104,
+    OFFSET_NEXT_INDEX_ID: 108,
+    OFFSET_PREV_INDEX_ID: 112,
+    OFFSET_IS_LEAF: 116,
+    OFFSET_KEYS_COUNT: 117,
+    OFFSET_VALUES_COUNT: 121,
+    OFFSET_KEYS_AND_VALUES: 128,
+    // 8-byte aligned (original 125 -> 128)
+    SIZE_INDEX_ID: 4,
+    SIZE_PARENT_INDEX_ID: 4,
+    SIZE_NEXT_INDEX_ID: 4,
+    SIZE_PREV_INDEX_ID: 4,
+    SIZE_IS_LEAF: 1,
+    SIZE_KEYS_COUNT: 4,
+    SIZE_VALUES_COUNT: 4,
+    SIZE_KEY: 8,
+    // Updated to 8 bytes for Float64
+    SIZE_VALUE: 8
+    // Updated to 8 bytes for Float64
+  };
   /**
-   * Verifies the checksum of the page.
-   * Calculates the checksum of the page body and compares it with the checksum stored in the header.
+   * Checks if the page type is `IndexPage`.
    * @param page Page data
-   * @returns boolean indicating if the checksum is valid
+   * @returns boolean indicating if the page type is `IndexPage`
    */
-  verifyChecksum(page) {
-    const body = this.getBody(page);
-    const checksum = crc32(body);
-    const storedChecksum = this.getChecksum(page);
-    return checksum === storedChecksum;
+  static IsIndexPage(page) {
+    return PageManager.GetPageType(page) === PageManager.CONSTANT.PAGE_TYPE_INDEX;
   }
   /**
-   * Sets the page header.
+   * Checks if the page type is `IndexPage`.
    * @param page Page data
-   * @param header Page header
+   * @returns boolean indicating if the page type is `IndexPage`
    */
-  setHeader(page, header) {
-    page.set(header);
+  isIndexPage(page) {
+    return _IndexPageManager.IsIndexPage(page);
   }
   /**
-   * Sets the page body.
+   * Gets the index ID of the page.
    * @param page Page data
-   * @param body Page body
+   * @returns Index ID
    */
-  setBody(page, body) {
-    page.set(body, _PageManager.CONSTANT.SIZE_PAGE_HEADER);
+  getIndexId(page) {
+    return bytesToNumber(
+      page,
+      _IndexPageManager.CONSTANT.OFFSET_INDEX_ID,
+      _IndexPageManager.CONSTANT.SIZE_INDEX_ID
+    );
   }
   /**
-   * Initializes the page.
+   * Gets the parent index ID of the page.
    * @param page Page data
-   * @param pageType Page type
-   * @param pageId Page ID
-   * @param nextPageId Next connected page ID
-   * @param remainingCapacity Remaining capacity
+   * @returns Parent index ID
    */
-  initial(page, pageType, pageId, nextPageId, remainingCapacity) {
-    this.setPageType(page, pageType);
-    this.setPageId(page, pageId);
-    this.setNextPageId(page, nextPageId);
-    this.setRemainingCapacity(page, remainingCapacity);
+  getParentIndexId(page) {
+    return bytesToNumber(
+      page,
+      _IndexPageManager.CONSTANT.OFFSET_PARENT_INDEX_ID,
+      _IndexPageManager.CONSTANT.SIZE_PARENT_INDEX_ID
+    );
   }
   /**
-   * Returns the body of the page.
+   * Gets the next index ID of the page.
    * @param page Page data
-   * @returns Page body
+   * @returns Next index ID
    */
-  getBody(page) {
-    return page.subarray(_PageManager.CONSTANT.SIZE_PAGE_HEADER);
+  getNextIndexId(page) {
+    return bytesToNumber(
+      page,
+      _IndexPageManager.CONSTANT.OFFSET_NEXT_INDEX_ID,
+      _IndexPageManager.CONSTANT.SIZE_NEXT_INDEX_ID
+    );
   }
   /**
-   * Creates a new page.
-   * @param pageSize Page size
-   * @param pageId Page ID
-   * @returns Created page data
+   * Gets the previous index ID of the page.
+   * @param page Page data
+   * @returns Previous index ID
    */
-  create(pageSize, pageId) {
-    const page = new Uint8Array(pageSize);
-    const headerSize = _PageManager.CONSTANT.SIZE_PAGE_HEADER;
-    const remainingCapacity = pageSize - headerSize;
-    this.initial(
+  getPrevIndexId(page) {
+    return bytesToNumber(
       page,
-      this.pageType,
-      pageId,
-      -1,
-      remainingCapacity
+      _IndexPageManager.CONSTANT.OFFSET_PREV_INDEX_ID,
+      _IndexPageManager.CONSTANT.SIZE_PREV_INDEX_ID
     );
-    return page;
-  }
-};
-var EmptyPageManager = class _EmptyPageManager extends PageManager {
-  get pageType() {
-    return PageManager.CONSTANT.PAGE_TYPE_EMPTY;
   }
   /**
-   * Checks if the page type is `EmptyPage`.
+   * Gets the is leaf of the page.
    * @param page Page data
-   * @returns boolean indicating if the page type is `EmptyPage`
+   * @returns Is leaf
    */
-  static IsEmptyPage(page) {
-    return PageManager.GetPageType(page) === PageManager.CONSTANT.PAGE_TYPE_EMPTY;
+  getIsLeaf(page) {
+    return bytesToNumber(
+      page,
+      _IndexPageManager.CONSTANT.OFFSET_IS_LEAF,
+      _IndexPageManager.CONSTANT.SIZE_IS_LEAF
+    ) === 1;
   }
   /**
-   * Checks if the page type is `EmptyPage`.
+   * Gets the keys count of the page.
    * @param page Page data
-   * @returns boolean indicating if the page type is `EmptyPage`
+   * @returns Keys count
    */
-  isEmptyPage(page) {
-    return _EmptyPageManager.IsEmptyPage(page);
+  getKeysCount(page) {
+    return bytesToNumber(
+      page,
+      _IndexPageManager.CONSTANT.OFFSET_KEYS_COUNT,
+      _IndexPageManager.CONSTANT.SIZE_KEYS_COUNT
+    );
   }
-};
-var DataPageManager = class _DataPageManager extends PageManager {
-  get pageType() {
-    return PageManager.CONSTANT.PAGE_TYPE_DATA;
+  /**
+   * Gets the values count of the page.
+   * @param page Page data
+   * @returns Values count
+   */
+  getValuesCount(page) {
+    return bytesToNumber(
+      page,
+      _IndexPageManager.CONSTANT.OFFSET_VALUES_COUNT,
+      _IndexPageManager.CONSTANT.SIZE_VALUES_COUNT
+    );
   }
-  row = new Row();
   /**
-   * Checks if the page type is `DataPage`.
+   * Sets the index ID of the page.
    * @param page Page data
-   * @returns boolean indicating if the page type is `DataPage`
+   * @param indexId Index ID
    */
-  static IsDataPage(page) {
-    return PageManager.GetPageType(page) === PageManager.CONSTANT.PAGE_TYPE_DATA;
+  setIndexId(page, indexId) {
+    numberToBytes(
+      indexId,
+      page,
+      _IndexPageManager.CONSTANT.OFFSET_INDEX_ID,
+      _IndexPageManager.CONSTANT.SIZE_INDEX_ID
+    );
   }
   /**
-   * Checks if the page type is `DataPage`.
+   * Sets the parent index ID of the page.
    * @param page Page data
-   * @returns boolean indicating if the page type is `DataPage`
+   * @param parentIndexId Parent index ID
    */
-  isDataPage(page) {
-    return _DataPageManager.IsDataPage(page);
+  setParentIndexId(page, parentIndexId) {
+    numberToBytes(
+      parentIndexId,
+      page,
+      _IndexPageManager.CONSTANT.OFFSET_PARENT_INDEX_ID,
+      _IndexPageManager.CONSTANT.SIZE_PARENT_INDEX_ID
+    );
   }
   /**
-   * Returns the offset of a row within the page.
+   * Sets the next index ID of the page.
    * @param page Page data
-   * @param slotIndex Slot index
-   * @returns Row offset within the page
+   * @param nextIndexId Next index ID
    */
-  getRowOffset(page, slotIndex) {
-    return bytesToNumber(
+  setNextIndexId(page, nextIndexId) {
+    numberToBytes(
+      nextIndexId,
       page,
-      page.length - PageManager.CONSTANT.SIZE_SLOT_OFFSET - slotIndex * PageManager.CONSTANT.SIZE_SLOT_OFFSET,
-      PageManager.CONSTANT.SIZE_SLOT_OFFSET
+      _IndexPageManager.CONSTANT.OFFSET_NEXT_INDEX_ID,
+      _IndexPageManager.CONSTANT.SIZE_NEXT_INDEX_ID
     );
   }
   /**
-   * Returns the row from the page.
+   * Sets the previous index ID of the page.
    * @param page Page data
-   * @param slotIndex Slot index
-   * @returns Row data within the page
+   * @param prevIndexId Previous index ID
    */
-  getRow(page, slotIndex) {
-    const offset = this.getRowOffset(page, slotIndex);
-    const headerSize = Row.CONSTANT.SIZE_HEADER;
-    const bodySize = this.row.getBodySize(page.subarray(offset));
-    const row = page.subarray(offset, offset + headerSize + bodySize);
-    return row;
+  setPrevIndexId(page, prevIndexId) {
+    numberToBytes(
+      prevIndexId,
+      page,
+      _IndexPageManager.CONSTANT.OFFSET_PREV_INDEX_ID,
+      _IndexPageManager.CONSTANT.SIZE_PREV_INDEX_ID
+    );
   }
   /**
-   * Returns the number of rows inserted into the page.
+   * Sets the is leaf of the page.
    * @param page Page data
-   * @returns Number of rows inserted
+   * @param isLeaf Is leaf
    */
-  getInsertedRowCount(page) {
-    return bytesToNumber(
+  setIsLeaf(page, isLeaf) {
+    numberToBytes(
+      isLeaf ? 1 : 0,
       page,
-      PageManager.CONSTANT.OFFSET_INSERTED_ROW_COUNT,
-      PageManager.CONSTANT.SIZE_INSERTED_ROW_COUNT
+      _IndexPageManager.CONSTANT.OFFSET_IS_LEAF,
+      _IndexPageManager.CONSTANT.SIZE_IS_LEAF
     );
   }
   /**
-   * Sets the offset of a row within the page.
+   * Sets the keys count of the page.
    * @param page Page data
-   * @param slotIndex Slot index
-   * @param offset Row offset within the page
+   * @param keysCount Keys count
    */
-  setRowOffset(page, slotIndex, offset) {
+  setKeysCount(page, keysCount) {
     numberToBytes(
-      offset,
+      keysCount,
       page,
-      page.length - PageManager.CONSTANT.SIZE_SLOT_OFFSET - slotIndex * PageManager.CONSTANT.SIZE_SLOT_OFFSET,
-      PageManager.CONSTANT.SIZE_SLOT_OFFSET
+      _IndexPageManager.CONSTANT.OFFSET_KEYS_COUNT,
+      _IndexPageManager.CONSTANT.SIZE_KEYS_COUNT
     );
   }
   /**
-   * Sets the number of rows inserted into the page.
+   * Sets the values count of the page.
    * @param page Page data
-   * @param insertedRowCount Number of rows inserted
+   * @param valuesCount Values count
    */
-  setInsertedRowCount(page, insertedRowCount) {
+  setValuesCount(page, valuesCount) {
     numberToBytes(
-      insertedRowCount,
+      valuesCount,
       page,
-      PageManager.CONSTANT.OFFSET_INSERTED_ROW_COUNT,
-      PageManager.CONSTANT.SIZE_INSERTED_ROW_COUNT
+      _IndexPageManager.CONSTANT.OFFSET_VALUES_COUNT,
+      _IndexPageManager.CONSTANT.SIZE_VALUES_COUNT
     );
   }
   /**
-   * Calculates if there is space for a row in the page and determines insertability.
-   * If insertable, returns the slot index to be inserted.
-   * If not, returns -1.
+   * Gets the keys of the page.
    * @param page Page data
-   * @param row Row data
-   * @returns Slot index for the row
+   * @returns Keys
    */
-  getNextSlotIndex(page, row) {
-    const slotOffsetSize = PageManager.CONSTANT.SIZE_SLOT_OFFSET;
-    const remainingCapacity = this.getRemainingCapacity(page);
-    const totalSize = row.length + slotOffsetSize;
-    return remainingCapacity >= totalSize ? this.getInsertedRowCount(page) : -1;
+  getKeys(page) {
+    const keysCount = this.getKeysCount(page);
+    const byteOffset = page.byteOffset + _IndexPageManager.CONSTANT.OFFSET_KEYS_AND_VALUES;
+    const keys = new Float64Array(page.buffer, byteOffset, keysCount);
+    return Array.from(keys);
   }
   /**
-   * Returns the position for the next row to be inserted.
+   * Gets the values of the page.
    * @param page Page data
-   * @returns Next insert position
+   * @returns Values
    */
-  getNextInsertPosition(page) {
-    const insertedRowCount = this.getInsertedRowCount(page);
-    if (insertedRowCount === 0) {
-      return _DataPageManager.CONSTANT.SIZE_PAGE_HEADER;
-    }
-    const lastRowIndex = insertedRowCount - 1;
-    const lastRowOffset = this.getRowOffset(page, lastRowIndex);
-    const lastRow = this.getRow(page, lastRowIndex);
-    return lastRowOffset + lastRow.length;
+  getValues(page) {
+    const keysCount = this.getKeysCount(page);
+    const valuesCount = this.getValuesCount(page);
+    const byteOffset = page.byteOffset + _IndexPageManager.CONSTANT.OFFSET_KEYS_AND_VALUES + keysCount * _IndexPageManager.CONSTANT.SIZE_KEY;
+    const values = new Float64Array(page.buffer, byteOffset, valuesCount);
+    return Array.from(values);
   }
   /**
-   * Inserts a row into the page. `getNextSlotIndex` should be called beforehand to verify availability.
+   * Sets the keys and values of the page.
    * @param page Page data
-   * @param row Row data
+   * @param keys Keys
+   * @param values Values
    */
-  insert(page, row) {
-    const slotOffsetSize = PageManager.CONSTANT.SIZE_SLOT_OFFSET;
-    const remainingCapacity = this.getRemainingCapacity(page);
-    const totalSize = row.length + slotOffsetSize;
-    if (remainingCapacity < totalSize) {
-      throw new Error("Not enough space to insert row");
-    }
-    const insertedRowCount = this.getInsertedRowCount(page);
-    const offset = this.getNextInsertPosition(page);
-    page.set(row, offset);
-    this.setRowOffset(page, insertedRowCount, offset);
-    this.setInsertedRowCount(page, insertedRowCount + 1);
-    this.setRemainingCapacity(page, remainingCapacity - totalSize);
+  setKeysAndValues(page, keys, values) {
+    const keysCount = keys.length;
+    const valuesCount = values.length;
+    const keyByteOffset = page.byteOffset + _IndexPageManager.CONSTANT.OFFSET_KEYS_AND_VALUES;
+    const keyDest = new Float64Array(page.buffer, keyByteOffset, keysCount);
+    keyDest.set(keys);
+    const valByteOffset = keyByteOffset + keysCount * _IndexPageManager.CONSTANT.SIZE_KEY;
+    const valDest = new Float64Array(page.buffer, valByteOffset, valuesCount);
+    valDest.set(values);
   }
 };
-var IndexPageManager = class _IndexPageManager extends PageManager {
+var MetadataPageManager = class _MetadataPageManager extends PageManager {
   get pageType() {
-    return PageManager.CONSTANT.PAGE_TYPE_INDEX;
+    return PageManager.CONSTANT.PAGE_TYPE_METADATA;
   }
   static CONSTANT = {
     ...PageManager.CONSTANT,
-    OFFSET_INDEX_ID: 100,
-    OFFSET_PARENT_INDEX_ID: 104,
-    OFFSET_NEXT_INDEX_ID: 108,
-    OFFSET_PREV_INDEX_ID: 112,
-    OFFSET_IS_LEAF: 116,
-    OFFSET_KEYS_COUNT: 117,
-    OFFSET_VALUES_COUNT: 121,
-    OFFSET_KEYS_AND_VALUES: 128,
-    // 8-byte aligned (original 125 -> 128)
-    SIZE_INDEX_ID: 4,
-    SIZE_PARENT_INDEX_ID: 4,
-    SIZE_NEXT_INDEX_ID: 4,
-    SIZE_PREV_INDEX_ID: 4,
-    SIZE_IS_LEAF: 1,
-    SIZE_KEYS_COUNT: 4,
-    SIZE_VALUES_COUNT: 4,
-    SIZE_KEY: 8,
-    // Updated to 8 bytes for Float64
-    SIZE_VALUE: 8
-    // Updated to 8 bytes for Float64
+    MAGIC_STRING: "DATAPLY",
+    OFFSET_MAGIC_STRING: 100,
+    OFFSET_PAGE_COUNT: 108,
+    OFFSET_PAGE_SIZE: 112,
+    OFFSET_ROW_COUNT: 116,
+    OFFSET_ROOT_INDEX_PAGE_ID: 122,
+    OFFSET_ROOT_INDEX_ORDER: 126,
+    OFFSET_LAST_INSERT_PAGE_ID: 130,
+    OFFSET_LAST_ROW_PK: 134,
+    OFFSET_BITMAP_PAGE_ID: 140,
+    OFFSET_FREE_PAGE_ID: 144,
+    SIZE_PAGE_COUNT: 4,
+    SIZE_PAGE_SIZE: 4,
+    SIZE_ROOT_INDEX_PAGE_ID: 4,
+    SIZE_ROOT_INDEX_ORDER: 4,
+    SIZE_LAST_INSERT_PAGE_ID: 4,
+    SIZE_ROW_PK: 6,
+    SIZE_BITMAP_PAGE_ID: 4,
+    SIZE_FREE_PAGE_ID: 4
   };
   /**
-   * Checks if the page type is `IndexPage`.
+   * Checks if the page type is `MetadataPage`.
    * @param page Page data
-   * @returns boolean indicating if the page type is `IndexPage`
+   * @returns boolean indicating if the page type is `MetadataPage`
    */
-  static IsIndexPage(page) {
-    return PageManager.GetPageType(page) === PageManager.CONSTANT.PAGE_TYPE_INDEX;
+  static IsMetadataPage(page) {
+    return PageManager.GetPageType(page) === PageManager.CONSTANT.PAGE_TYPE_METADATA;
   }
   /**
-   * Checks if the page type is `IndexPage`.
+   * Checks if the page type is `MetadataPage`.
    * @param page Page data
-   * @returns boolean indicating if the page type is `IndexPage`
+   * @returns boolean indicating if the page type is `MetadataPage`
    */
-  isIndexPage(page) {
-    return _IndexPageManager.IsIndexPage(page);
+  isMetadataPage(page) {
+    return _MetadataPageManager.IsMetadataPage(page);
+  }
+  /**
+   * Verifies if the page is a valid metadata page.
+   * @param page Page data
+   * @returns Whether it is a metadata page
+   */
+  static Verify(page) {
+    const start = _MetadataPageManager.CONSTANT.OFFSET_MAGIC_STRING;
+    const end = _MetadataPageManager.CONSTANT.OFFSET_MAGIC_STRING + _MetadataPageManager.CONSTANT.MAGIC_STRING.length;
+    const magicString = page.subarray(start, end);
+    if (!magicString.every((byte, index) => byte === _MetadataPageManager.CONSTANT.MAGIC_STRING.charCodeAt(index))) {
+      return false;
+    }
+    return true;
+  }
+  /**
+   * Returns the number of pages stored in the database.
+   * @param page Page data
+   * @returns Number of pages
+   */
+  getPageCount(page) {
+    return bytesToNumber(
+      page,
+      _MetadataPageManager.CONSTANT.OFFSET_PAGE_COUNT,
+      _MetadataPageManager.CONSTANT.SIZE_PAGE_COUNT
+    );
+  }
+  /**
+   * Returns the database page size.
+   * @param page Page data
+   * @returns Page size
+   */
+  getPageSize(page) {
+    return bytesToNumber(
+      page,
+      _MetadataPageManager.CONSTANT.OFFSET_PAGE_SIZE,
+      _MetadataPageManager.CONSTANT.SIZE_PAGE_SIZE
+    );
   }
   /**
-   * Gets the index ID of the page.
+   * Returns the Root Index Page ID of the database.
    * @param page Page data
-   * @returns Index ID
+   * @returns Root Index Page ID
    */
-  getIndexId(page) {
-    return bytesToNumber(
+  getRootIndexPageId(page) {
+    const id = bytesToNumber(
       page,
-      _IndexPageManager.CONSTANT.OFFSET_INDEX_ID,
-      _IndexPageManager.CONSTANT.SIZE_INDEX_ID
+      _MetadataPageManager.CONSTANT.OFFSET_ROOT_INDEX_PAGE_ID,
+      _MetadataPageManager.CONSTANT.SIZE_ROOT_INDEX_PAGE_ID
     );
+    return id === 4294967295 ? -1 : id;
   }
   /**
-   * Gets the parent index ID of the page.
+   * Returns the order of the database Root Index Page.
    * @param page Page data
-   * @returns Parent index ID
+   * @returns Root Index Page order
    */
-  getParentIndexId(page) {
+  getRootIndexOrder(page) {
     return bytesToNumber(
       page,
-      _IndexPageManager.CONSTANT.OFFSET_PARENT_INDEX_ID,
-      _IndexPageManager.CONSTANT.SIZE_PARENT_INDEX_ID
+      _MetadataPageManager.CONSTANT.OFFSET_ROOT_INDEX_ORDER,
+      _MetadataPageManager.CONSTANT.SIZE_ROOT_INDEX_ORDER
     );
   }
   /**
-   * Gets the next index ID of the page.
+   * Returns the ID of the last insertion page.
    * @param page Page data
-   * @returns Next index ID
+   * @returns Last insert page ID
    */
-  getNextIndexId(page) {
+  getLastInsertPageId(page) {
     return bytesToNumber(
       page,
-      _IndexPageManager.CONSTANT.OFFSET_NEXT_INDEX_ID,
-      _IndexPageManager.CONSTANT.SIZE_NEXT_INDEX_ID
+      _MetadataPageManager.CONSTANT.OFFSET_LAST_INSERT_PAGE_ID,
+      _MetadataPageManager.CONSTANT.SIZE_LAST_INSERT_PAGE_ID
     );
   }
   /**
-   * Gets the previous index ID of the page.
+   * Returns the PK of the last inserted row in the database.
    * @param page Page data
-   * @returns Previous index ID
+   * @returns Last inserted row PK
    */
-  getPrevIndexId(page) {
+  getLastRowPk(page) {
     return bytesToNumber(
       page,
-      _IndexPageManager.CONSTANT.OFFSET_PREV_INDEX_ID,
-      _IndexPageManager.CONSTANT.SIZE_PREV_INDEX_ID
+      _MetadataPageManager.CONSTANT.OFFSET_LAST_ROW_PK,
+      _MetadataPageManager.CONSTANT.SIZE_ROW_PK
     );
   }
   /**
-   * Gets the is leaf of the page.
+   * Returns the number of rows in the database.
    * @param page Page data
-   * @returns Is leaf
+   * @returns Number of rows
    */
-  getIsLeaf(page) {
+  getRowCount(page) {
     return bytesToNumber(
       page,
-      _IndexPageManager.CONSTANT.OFFSET_IS_LEAF,
-      _IndexPageManager.CONSTANT.SIZE_IS_LEAF
-    ) === 1;
+      _MetadataPageManager.CONSTANT.OFFSET_ROW_COUNT,
+      _MetadataPageManager.CONSTANT.SIZE_ROW_PK
+    );
   }
   /**
-   * Gets the keys count of the page.
+   * Returns the ID of the bitmap page.
    * @param page Page data
-   * @returns Keys count
+   * @returns Bitmap page ID
    */
-  getKeysCount(page) {
+  getBitmapPageId(page) {
     return bytesToNumber(
       page,
-      _IndexPageManager.CONSTANT.OFFSET_KEYS_COUNT,
-      _IndexPageManager.CONSTANT.SIZE_KEYS_COUNT
+      _MetadataPageManager.CONSTANT.OFFSET_BITMAP_PAGE_ID,
+      _MetadataPageManager.CONSTANT.SIZE_BITMAP_PAGE_ID
     );
   }
   /**
-   * Gets the values count of the page.
+   * Returns the ID of the free page.
    * @param page Page data
-   * @returns Values count
+   * @returns Free page ID
    */
-  getValuesCount(page) {
-    return bytesToNumber(
+  getFreePageId(page) {
+    const id = bytesToNumber(
       page,
-      _IndexPageManager.CONSTANT.OFFSET_VALUES_COUNT,
-      _IndexPageManager.CONSTANT.SIZE_VALUES_COUNT
+      _MetadataPageManager.CONSTANT.OFFSET_FREE_PAGE_ID,
+      _MetadataPageManager.CONSTANT.SIZE_FREE_PAGE_ID
     );
+    return id === 4294967295 ? -1 : id;
   }
   /**
-   * Sets the index ID of the page.
+   * Sets the number of pages stored in the database.
    * @param page Page data
-   * @param indexId Index ID
+   * @param pageCount Number of pages
    */
-  setIndexId(page, indexId) {
+  setPageCount(page, pageCount) {
     numberToBytes(
-      indexId,
+      pageCount,
       page,
-      _IndexPageManager.CONSTANT.OFFSET_INDEX_ID,
-      _IndexPageManager.CONSTANT.SIZE_INDEX_ID
+      _MetadataPageManager.CONSTANT.OFFSET_PAGE_COUNT,
+      _MetadataPageManager.CONSTANT.SIZE_PAGE_COUNT
     );
   }
   /**
-   * Sets the parent index ID of the page.
+   * Sets the database page size.
    * @param page Page data
-   * @param parentIndexId Parent index ID
+   * @param pageSize Page size
    */
-  setParentIndexId(page, parentIndexId) {
+  setPageSize(page, pageSize) {
     numberToBytes(
-      parentIndexId,
+      pageSize,
       page,
-      _IndexPageManager.CONSTANT.OFFSET_PARENT_INDEX_ID,
-      _IndexPageManager.CONSTANT.SIZE_PARENT_INDEX_ID
+      _MetadataPageManager.CONSTANT.OFFSET_PAGE_SIZE,
+      _MetadataPageManager.CONSTANT.SIZE_PAGE_SIZE
     );
   }
   /**
-   * Sets the next index ID of the page.
+   * Sets the Root Index Page ID of the database.
    * @param page Page data
-   * @param nextIndexId Next index ID
+   * @param rootIndexPageId Root Index Page ID
    */
-  setNextIndexId(page, nextIndexId) {
+  setRootIndexPageId(page, rootIndexPageId) {
     numberToBytes(
-      nextIndexId,
+      rootIndexPageId,
       page,
-      _IndexPageManager.CONSTANT.OFFSET_NEXT_INDEX_ID,
-      _IndexPageManager.CONSTANT.SIZE_NEXT_INDEX_ID
+      _MetadataPageManager.CONSTANT.OFFSET_ROOT_INDEX_PAGE_ID,
+      _MetadataPageManager.CONSTANT.SIZE_ROOT_INDEX_PAGE_ID
     );
   }
   /**
-   * Sets the previous index ID of the page.
+   * Sets the order of the database Root Index Page.
    * @param page Page data
-   * @param prevIndexId Previous index ID
+   * @param order Root Index Page order
    */
-  setPrevIndexId(page, prevIndexId) {
+  setRootIndexOrder(page, order) {
     numberToBytes(
-      prevIndexId,
+      order,
       page,
-      _IndexPageManager.CONSTANT.OFFSET_PREV_INDEX_ID,
-      _IndexPageManager.CONSTANT.SIZE_PREV_INDEX_ID
+      _MetadataPageManager.CONSTANT.OFFSET_ROOT_INDEX_ORDER,
+      _MetadataPageManager.CONSTANT.SIZE_ROOT_INDEX_ORDER
     );
   }
   /**
-   * Sets the is leaf of the page.
+   * Sets the magic string of the page.
    * @param page Page data
-   * @param isLeaf Is leaf
    */
-  setIsLeaf(page, isLeaf) {
-    numberToBytes(
-      isLeaf ? 1 : 0,
-      page,
-      _IndexPageManager.CONSTANT.OFFSET_IS_LEAF,
-      _IndexPageManager.CONSTANT.SIZE_IS_LEAF
-    );
+  setMagicString(page) {
+    const encoding = new TextEncoder();
+    const buffer = encoding.encode(_MetadataPageManager.CONSTANT.MAGIC_STRING);
+    page.set(buffer, _MetadataPageManager.CONSTANT.OFFSET_MAGIC_STRING);
   }
   /**
-   * Sets the keys count of the page.
+   * Sets the ID of the last insertion page.
    * @param page Page data
-   * @param keysCount Keys count
+   * @param lastInsertPageId Last insert page ID
    */
-  setKeysCount(page, keysCount) {
+  setLastInsertPageId(page, lastInsertPageId) {
     numberToBytes(
-      keysCount,
+      lastInsertPageId,
       page,
-      _IndexPageManager.CONSTANT.OFFSET_KEYS_COUNT,
-      _IndexPageManager.CONSTANT.SIZE_KEYS_COUNT
+      _MetadataPageManager.CONSTANT.OFFSET_LAST_INSERT_PAGE_ID,
+      _MetadataPageManager.CONSTANT.SIZE_LAST_INSERT_PAGE_ID
     );
   }
   /**
-   * Sets the values count of the page.
+   * Sets the PK of the last inserted row in the database.
    * @param page Page data
-   * @param valuesCount Values count
+   * @param lastRowPk Last inserted row PK
    */
-  setValuesCount(page, valuesCount) {
+  setLastRowPk(page, lastRowPk) {
     numberToBytes(
-      valuesCount,
+      lastRowPk,
       page,
-      _IndexPageManager.CONSTANT.OFFSET_VALUES_COUNT,
-      _IndexPageManager.CONSTANT.SIZE_VALUES_COUNT
+      _MetadataPageManager.CONSTANT.OFFSET_LAST_ROW_PK,
+      Row.CONSTANT.SIZE_PK
     );
   }
   /**
-   * Gets the keys of the page.
+   * Sets the number of rows in the database.
    * @param page Page data
-   * @returns Keys
+   * @param rowCount Number of rows
    */
-  getKeys(page) {
-    const keysCount = this.getKeysCount(page);
-    const byteOffset = page.byteOffset + _IndexPageManager.CONSTANT.OFFSET_KEYS_AND_VALUES;
-    const keys = new Float64Array(page.buffer, byteOffset, keysCount);
-    return Array.from(keys);
+  setRowCount(page, rowCount) {
+    numberToBytes(
+      rowCount,
+      page,
+      _MetadataPageManager.CONSTANT.OFFSET_ROW_COUNT,
+      Row.CONSTANT.SIZE_PK
+    );
   }
   /**
-   * Gets the values of the page.
+   * Sets the ID of the bitmap page.
    * @param page Page data
-   * @returns Values
+   * @param bitmapPageId Bitmap page ID
    */
-  getValues(page) {
-    const keysCount = this.getKeysCount(page);
-    const valuesCount = this.getValuesCount(page);
-    const byteOffset = page.byteOffset + _IndexPageManager.CONSTANT.OFFSET_KEYS_AND_VALUES + keysCount * _IndexPageManager.CONSTANT.SIZE_KEY;
-    const values = new Float64Array(page.buffer, byteOffset, valuesCount);
-    return Array.from(values);
+  setBitmapPageId(page, bitmapPageId) {
+    numberToBytes(
+      bitmapPageId,
+      page,
+      _MetadataPageManager.CONSTANT.OFFSET_BITMAP_PAGE_ID,
+      _MetadataPageManager.CONSTANT.SIZE_BITMAP_PAGE_ID
+    );
   }
   /**
-   * Sets the keys and values of the page.
+   * Sets the ID of the free page.
    * @param page Page data
-   * @param keys Keys
-   * @param values Values
+   * @param pageId Free page ID
    */
-  setKeysAndValues(page, keys, values) {
-    const keysCount = keys.length;
-    const valuesCount = values.length;
-    const keyByteOffset = page.byteOffset + _IndexPageManager.CONSTANT.OFFSET_KEYS_AND_VALUES;
-    const keyDest = new Float64Array(page.buffer, keyByteOffset, keysCount);
-    keyDest.set(keys);
-    const valByteOffset = keyByteOffset + keysCount * _IndexPageManager.CONSTANT.SIZE_KEY;
-    const valDest = new Float64Array(page.buffer, valByteOffset, valuesCount);
-    valDest.set(values);
+  setFreePageId(page, pageId) {
+    numberToBytes(
+      pageId,
+      page,
+      _MetadataPageManager.CONSTANT.OFFSET_FREE_PAGE_ID,
+      _MetadataPageManager.CONSTANT.SIZE_FREE_PAGE_ID
+    );
   }
 };
-var MetadataPageManager = class _MetadataPageManager extends PageManager {
+var BitmapPageManager = class _BitmapPageManager extends PageManager {
   get pageType() {
-    return PageManager.CONSTANT.PAGE_TYPE_METADATA;
+    return PageManager.CONSTANT.PAGE_TYPE_BITMAP;
   }
-  static CONSTANT = {
-    ...PageManager.CONSTANT,
-    MAGIC_STRING: "DATAPLY",
-    OFFSET_MAGIC_STRING: 100,
-    OFFSET_PAGE_COUNT: 108,
-    OFFSET_PAGE_SIZE: 112,
-    OFFSET_ROW_COUNT: 116,
-    OFFSET_ROOT_INDEX_PAGE_ID: 122,
-    OFFSET_ROOT_INDEX_ORDER: 126,
-    OFFSET_LAST_INSERT_PAGE_ID: 130,
-    OFFSET_LAST_ROW_PK: 134,
-    OFFSET_BITMAP_PAGE_ID: 140,
-    OFFSET_FREE_PAGE_ID: 144,
-    SIZE_PAGE_COUNT: 4,
-    SIZE_PAGE_SIZE: 4,
-    SIZE_ROOT_INDEX_PAGE_ID: 4,
-    SIZE_ROOT_INDEX_ORDER: 4,
-    SIZE_LAST_INSERT_PAGE_ID: 4,
-    SIZE_ROW_PK: 6,
-    SIZE_BITMAP_PAGE_ID: 4,
-    SIZE_FREE_PAGE_ID: 4
-  };
   /**
-   * Checks if the page type is `MetadataPage`.
+   * Checks if the page type is `BitmapPage`.
    * @param page Page data
-   * @returns boolean indicating if the page type is `MetadataPage`
+   * @returns boolean indicating if the page type is `BitmapPage`
+   */
+  static IsBitmapPage(page) {
+    return PageManager.GetPageType(page) === PageManager.CONSTANT.PAGE_TYPE_BITMAP;
+  }
+  /**
+   * Checks if the page type is `BitmapPage`.
+   * @param page Page data
+   * @returns boolean indicating if the page type is `BitmapPage`
    */
-  static IsMetadataPage(page) {
-    return PageManager.GetPageType(page) === PageManager.CONSTANT.PAGE_TYPE_METADATA;
+  isBitmapPage(page) {
+    return _BitmapPageManager.IsBitmapPage(page);
   }
   /**
-   * Checks if the page type is `MetadataPage`.
+   * Checks if a page is empty.
    * @param page Page data
-   * @returns boolean indicating if the page type is `MetadataPage`
+   * @param index Bitmap index
+   * @returns boolean indicating if the page is empty
    */
-  isMetadataPage(page) {
-    return _MetadataPageManager.IsMetadataPage(page);
+  isEmptyPage(page, index) {
+    return bytesToNumber(page, index, 1) === 0;
   }
   /**
-   * Verifies if the page is a valid metadata page.
+   * Gets a bit from the bitmap page.
    * @param page Page data
-   * @returns Whether it is a metadata page
+   * @param index Bit index
+   * @returns boolean indicating if the bit is set
    */
-  static Verify(page) {
-    const start = _MetadataPageManager.CONSTANT.OFFSET_MAGIC_STRING;
-    const end = _MetadataPageManager.CONSTANT.OFFSET_MAGIC_STRING + _MetadataPageManager.CONSTANT.MAGIC_STRING.length;
-    const magicString = page.subarray(start, end);
-    if (!magicString.every((byte, index) => byte === _MetadataPageManager.CONSTANT.MAGIC_STRING.charCodeAt(index))) {
-      return false;
-    }
-    return true;
+  getBit(page, index) {
+    const bitOffset = Math.floor(index / 8);
+    const offset = _BitmapPageManager.CONSTANT.SIZE_PAGE_HEADER + bitOffset;
+    const value = bytesToNumber(page, offset, 1);
+    return getBit(value, index % 8);
   }
   /**
-   * Returns the number of pages stored in the database.
+   * Sets a bit in the bitmap page.
    * @param page Page data
-   * @returns Number of pages
+   * @param index Bit index
+   * @param flag boolean indicating if the bit is set
    */
-  getPageCount(page) {
-    return bytesToNumber(
-      page,
-      _MetadataPageManager.CONSTANT.OFFSET_PAGE_COUNT,
-      _MetadataPageManager.CONSTANT.SIZE_PAGE_COUNT
-    );
+  setBit(page, index, flag) {
+    const bitOffset = Math.floor(index / 8);
+    const offset = _BitmapPageManager.CONSTANT.SIZE_PAGE_HEADER + bitOffset;
+    const value = bytesToNumber(page, offset, 1);
+    const newValue = setBit(value, index % 8, flag);
+    numberToBytes(newValue, page, offset, 1);
+  }
+};
+var OverflowPageManager = class _OverflowPageManager extends PageManager {
+  get pageType() {
+    return PageManager.CONSTANT.PAGE_TYPE_OVERFLOW;
   }
   /**
-   * Returns the database page size.
+   * Checks if the page type is `OverflowPage`.
    * @param page Page data
-   * @returns Page size
+   * @returns boolean indicating if the page type is `OverflowPage`
    */
-  getPageSize(page) {
-    return bytesToNumber(
-      page,
-      _MetadataPageManager.CONSTANT.OFFSET_PAGE_SIZE,
-      _MetadataPageManager.CONSTANT.SIZE_PAGE_SIZE
-    );
+  static IsOverflowPage(page) {
+    return PageManager.GetPageType(page) === PageManager.CONSTANT.PAGE_TYPE_OVERFLOW;
   }
   /**
-   * Returns the Root Index Page ID of the database.
+   * Checks if the page type is `OverflowPage`.
    * @param page Page data
-   * @returns Root Index Page ID
+   * @returns boolean indicating if the page type is `OverflowPage`
    */
-  getRootIndexPageId(page) {
-    const id = bytesToNumber(
-      page,
-      _MetadataPageManager.CONSTANT.OFFSET_ROOT_INDEX_PAGE_ID,
-      _MetadataPageManager.CONSTANT.SIZE_ROOT_INDEX_PAGE_ID
-    );
-    return id === 4294967295 ? -1 : id;
+  isOverflowPage(page) {
+    return _OverflowPageManager.IsOverflowPage(page);
+  }
+};
+var UnknownPageManager = class _UnknownPageManager extends PageManager {
+  get pageType() {
+    return PageManager.CONSTANT.PAGE_TYPE_UNKNOWN;
   }
   /**
-   * Returns the order of the database Root Index Page.
+   * Checks if the page type is `UnknownPage`.
    * @param page Page data
-   * @returns Root Index Page order
+   * @returns boolean indicating if the page type is `UnknownPage`
    */
-  getRootIndexOrder(page) {
-    return bytesToNumber(
-      page,
-      _MetadataPageManager.CONSTANT.OFFSET_ROOT_INDEX_ORDER,
-      _MetadataPageManager.CONSTANT.SIZE_ROOT_INDEX_ORDER
-    );
+  static IsUnknownPage(page) {
+    return PageManager.GetPageType(page) === PageManager.CONSTANT.PAGE_TYPE_UNKNOWN;
   }
   /**
-   * Returns the ID of the last insertion page.
+   * Checks if the page is `UnknownPage`.
    * @param page Page data
-   * @returns Last insert page ID
+   * @returns `true` if the page is `UnknownPage`, otherwise `false`
    */
-  getLastInsertPageId(page) {
-    return bytesToNumber(
-      page,
-      _MetadataPageManager.CONSTANT.OFFSET_LAST_INSERT_PAGE_ID,
-      _MetadataPageManager.CONSTANT.SIZE_LAST_INSERT_PAGE_ID
-    );
+  isUnknownPage(page) {
+    return _UnknownPageManager.IsUnknownPage(page);
   }
+};
+var PageManagerFactory = class _PageManagerFactory {
+  static EmptyPage = new EmptyPageManager();
+  static DataPage = new DataPageManager();
+  static IndexPage = new IndexPageManager();
+  static MetadataPage = new MetadataPageManager();
+  static BitmapPage = new BitmapPageManager();
+  static OverflowPage = new OverflowPageManager();
+  static UnknownPage = new UnknownPageManager();
   /**
-   * Returns the PK of the last inserted row in the database.
+   * Returns the page type.
    * @param page Page data
-   * @returns Last inserted row PK
+   * @returns Page type
    */
-  getLastRowPk(page) {
-    return bytesToNumber(
-      page,
-      _MetadataPageManager.CONSTANT.OFFSET_LAST_ROW_PK,
-      _MetadataPageManager.CONSTANT.SIZE_ROW_PK
-    );
+  getPageType(page) {
+    return bytesToNumber(page, PageManager.CONSTANT.OFFSET_PAGE_TYPE, PageManager.CONSTANT.SIZE_PAGE_TYPE);
   }
   /**
-   * Returns the number of rows in the database.
+   * Checks if the page is `EmptyPage`.
    * @param page Page data
-   * @returns Number of rows
+   * @returns `true` if the page is `EmptyPage`, otherwise `false`
    */
-  getRowCount(page) {
-    return bytesToNumber(
-      page,
-      _MetadataPageManager.CONSTANT.OFFSET_ROW_COUNT,
-      _MetadataPageManager.CONSTANT.SIZE_ROW_PK
-    );
+  isEmptyPage(page) {
+    return EmptyPageManager.IsEmptyPage(page);
   }
   /**
-   * Returns the ID of the bitmap page.
+   * Checks if the page is `DataPage`.
    * @param page Page data
-   * @returns Bitmap page ID
+   * @returns `true` if the page is `DataPage`, otherwise `false`
    */
-  getBitmapPageId(page) {
-    return bytesToNumber(
-      page,
-      _MetadataPageManager.CONSTANT.OFFSET_BITMAP_PAGE_ID,
-      _MetadataPageManager.CONSTANT.SIZE_BITMAP_PAGE_ID
-    );
+  isDataPage(page) {
+    return DataPageManager.IsDataPage(page);
   }
   /**
-   * Returns the ID of the free page.
+   * Checks if the page is `IndexPage`.
    * @param page Page data
-   * @returns Free page ID
+   * @returns `true` if the page is `IndexPage`, otherwise `false`
    */
-  getFreePageId(page) {
-    const id = bytesToNumber(
-      page,
-      _MetadataPageManager.CONSTANT.OFFSET_FREE_PAGE_ID,
-      _MetadataPageManager.CONSTANT.SIZE_FREE_PAGE_ID
-    );
-    return id === 4294967295 ? -1 : id;
+  isIndexPage(page) {
+    return IndexPageManager.IsIndexPage(page);
   }
   /**
-   * Sets the number of pages stored in the database.
+   * Checks if the page is `MetadataPage`.
    * @param page Page data
-   * @param pageCount Number of pages
+   * @returns `true` if the page is `MetadataPage`, otherwise `false`
    */
-  setPageCount(page, pageCount) {
-    numberToBytes(
-      pageCount,
-      page,
-      _MetadataPageManager.CONSTANT.OFFSET_PAGE_COUNT,
-      _MetadataPageManager.CONSTANT.SIZE_PAGE_COUNT
-    );
+  isMetadataPage(page) {
+    return MetadataPageManager.IsMetadataPage(page);
   }
   /**
-   * Sets the database page size.
+   * Checks if the page is `BitmapPage`.
    * @param page Page data
-   * @param pageSize Page size
+   * @returns `true` if the page is `BitmapPage`, otherwise `false`
    */
-  setPageSize(page, pageSize) {
-    numberToBytes(
-      pageSize,
-      page,
-      _MetadataPageManager.CONSTANT.OFFSET_PAGE_SIZE,
-      _MetadataPageManager.CONSTANT.SIZE_PAGE_SIZE
-    );
+  isBitmapPage(page) {
+    return BitmapPageManager.IsBitmapPage(page);
   }
   /**
-   * Sets the Root Index Page ID of the database.
+   * Checks if the page is `OverflowPage`.
    * @param page Page data
-   * @param rootIndexPageId Root Index Page ID
+   * @returns `true` if the page is `OverflowPage`, otherwise `false`
    */
-  setRootIndexPageId(page, rootIndexPageId) {
-    numberToBytes(
-      rootIndexPageId,
-      page,
-      _MetadataPageManager.CONSTANT.OFFSET_ROOT_INDEX_PAGE_ID,
-      _MetadataPageManager.CONSTANT.SIZE_ROOT_INDEX_PAGE_ID
-    );
+  isOverflowPage(page) {
+    return OverflowPageManager.IsOverflowPage(page);
   }
   /**
-   * Sets the order of the database Root Index Page.
+   * Checks if the page is `UnknownPage`.
    * @param page Page data
-   * @param order Root Index Page order
+   * @returns `true` if the page is `UnknownPage`, otherwise `false`
    */
-  setRootIndexOrder(page, order) {
-    numberToBytes(
-      order,
-      page,
-      _MetadataPageManager.CONSTANT.OFFSET_ROOT_INDEX_ORDER,
-      _MetadataPageManager.CONSTANT.SIZE_ROOT_INDEX_ORDER
-    );
+  isUnknownPage(page) {
+    return UnknownPageManager.IsUnknownPage(page);
+  }
+  getManager(page) {
+    switch (this.getPageType(page)) {
+      case PageManager.CONSTANT.PAGE_TYPE_EMPTY:
+        return _PageManagerFactory.EmptyPage;
+      case PageManager.CONSTANT.PAGE_TYPE_METADATA:
+        return _PageManagerFactory.MetadataPage;
+      case PageManager.CONSTANT.PAGE_TYPE_BITMAP:
+        return _PageManagerFactory.BitmapPage;
+      case PageManager.CONSTANT.PAGE_TYPE_INDEX:
+        return _PageManagerFactory.IndexPage;
+      case PageManager.CONSTANT.PAGE_TYPE_DATA:
+        return _PageManagerFactory.DataPage;
+      case PageManager.CONSTANT.PAGE_TYPE_OVERFLOW:
+        return _PageManagerFactory.OverflowPage;
+      case PageManager.CONSTANT.PAGE_TYPE_UNKNOWN:
+        return _PageManagerFactory.UnknownPage;
+      default:
+        throw new Error(`Invalid page type: ${this.getPageType(page)}`);
+    }
+  }
+  getManagerFromType(pageType) {
+    switch (pageType) {
+      case PageManager.CONSTANT.PAGE_TYPE_EMPTY:
+        return _PageManagerFactory.EmptyPage;
+      case PageManager.CONSTANT.PAGE_TYPE_METADATA:
+        return _PageManagerFactory.MetadataPage;
+      case PageManager.CONSTANT.PAGE_TYPE_BITMAP:
+        return _PageManagerFactory.BitmapPage;
+      case PageManager.CONSTANT.PAGE_TYPE_INDEX:
+        return _PageManagerFactory.IndexPage;
+      case PageManager.CONSTANT.PAGE_TYPE_DATA:
+        return _PageManagerFactory.DataPage;
+      case PageManager.CONSTANT.PAGE_TYPE_OVERFLOW:
+        return _PageManagerFactory.OverflowPage;
+      case PageManager.CONSTANT.PAGE_TYPE_UNKNOWN:
+        return _PageManagerFactory.UnknownPage;
+      default:
+        throw new Error(`Invalid page type: ${pageType}`);
+    }
   }
-  /**
-   * Sets the magic string of the page.
-   * @param page Page data
-   */
-  setMagicString(page) {
-    const encoding = new TextEncoder();
-    const buffer = encoding.encode(_MetadataPageManager.CONSTANT.MAGIC_STRING);
-    page.set(buffer, _MetadataPageManager.CONSTANT.OFFSET_MAGIC_STRING);
+};
+
+// src/core/DataplyAPI.ts
+var import_node_fs3 = __toESM(require("node:fs"));
+
+// node_modules/hookall/dist/esm/index.mjs
+var HookallStore = class extends WeakMap {
+  ensure(obj, key) {
+    if (!this.has(obj)) {
+      const scope2 = {};
+      this.set(obj, scope2);
+    }
+    const scope = this.get(obj);
+    if (!Object.prototype.hasOwnProperty.call(scope, key)) {
+      scope[key] = /* @__PURE__ */ new Map();
+    }
+    return scope[key];
   }
+};
+var Hookall = class _Hookall {
+  static Global = {};
+  static _Store = new HookallStore();
+  beforeHooks;
+  afterHooks;
   /**
-   * Sets the ID of the last insertion page.
-   * @param page Page data
-   * @param lastInsertPageId Last insert page ID
+   * Create hook system. you can pass a target object or undefined.
+   * If you pass a object, the hook system will be work for object locally. You're going to want this kind of usage in general.
+   * If not specified, will be work for global. This is useful when you want to share your work with multiple files.
+   * @param target The object to work with locally. If not specified, will be work for global.
    */
-  setLastInsertPageId(page, lastInsertPageId) {
-    numberToBytes(
-      lastInsertPageId,
-      page,
-      _MetadataPageManager.CONSTANT.OFFSET_LAST_INSERT_PAGE_ID,
-      _MetadataPageManager.CONSTANT.SIZE_LAST_INSERT_PAGE_ID
-    );
+  constructor(target) {
+    this.beforeHooks = _Hookall._Store.ensure(target, "before");
+    this.afterHooks = _Hookall._Store.ensure(target, "after");
   }
-  /**
-   * Sets the PK of the last inserted row in the database.
-   * @param page Page data
-   * @param lastRowPk Last inserted row PK
-   */
-  setLastRowPk(page, lastRowPk) {
-    numberToBytes(
-      lastRowPk,
-      page,
-      _MetadataPageManager.CONSTANT.OFFSET_LAST_ROW_PK,
-      Row.CONSTANT.SIZE_PK
-    );
+  _ensureCommand(hooks, command) {
+    if (!hooks.has(command)) {
+      hooks.set(command, []);
+    }
+    return hooks.get(command);
   }
-  /**
-   * Sets the number of rows in the database.
-   * @param page Page data
-   * @param rowCount Number of rows
-   */
-  setRowCount(page, rowCount) {
-    numberToBytes(
-      rowCount,
-      page,
-      _MetadataPageManager.CONSTANT.OFFSET_ROW_COUNT,
-      Row.CONSTANT.SIZE_PK
-    );
+  _createWrapper(command, callback, repeat) {
+    return {
+      callback,
+      command,
+      repeat
+    };
   }
-  /**
-   * Sets the ID of the bitmap page.
-   * @param page Page data
-   * @param bitmapPageId Bitmap page ID
-   */
-  setBitmapPageId(page, bitmapPageId) {
-    numberToBytes(
-      bitmapPageId,
-      page,
-      _MetadataPageManager.CONSTANT.OFFSET_BITMAP_PAGE_ID,
-      _MetadataPageManager.CONSTANT.SIZE_BITMAP_PAGE_ID
-    );
+  _on(hooks, command, callback, repeat) {
+    const wrappers = this._ensureCommand(hooks, command);
+    const wrapper = this._createWrapper(command, callback, repeat);
+    wrappers.unshift(wrapper);
   }
   /**
-   * Sets the ID of the free page.
-   * @param page Page data
-   * @param pageId Free page ID
+   * You register a preprocessing function, which is called before the callback function of the `trigger` method.
+   * The value returned by this function is passed as a parameter to the `trigger` method's callback function.
+   * If you register multiple preprocessing functions, they are executed in order, with each function receiving the value returned by the previous one as a parameter.
+   * @param command Command to work.
+   * @param callback Preprocessing function to register.
    */
-  setFreePageId(page, pageId) {
-    numberToBytes(
-      pageId,
-      page,
-      _MetadataPageManager.CONSTANT.OFFSET_FREE_PAGE_ID,
-      _MetadataPageManager.CONSTANT.SIZE_FREE_PAGE_ID
-    );
-  }
-};
-var BitmapPageManager = class _BitmapPageManager extends PageManager {
-  get pageType() {
-    return PageManager.CONSTANT.PAGE_TYPE_BITMAP;
+  onBefore(command, callback) {
+    this._on(this.beforeHooks, command, callback, -1);
+    return this;
   }
   /**
-   * Checks if the page type is `BitmapPage`.
-   * @param page Page data
-   * @returns boolean indicating if the page type is `BitmapPage`
+   * Similar to the `onBefore` method, but it only runs once.
+   * For more details, please refer to the `onBefore` method.
+   * @param command Command to work.
+   * @param callback Preprocessing function to register.
    */
-  static IsBitmapPage(page) {
-    return PageManager.GetPageType(page) === PageManager.CONSTANT.PAGE_TYPE_BITMAP;
+  onceBefore(command, callback) {
+    this._on(this.beforeHooks, command, callback, 1);
+    return this;
   }
   /**
-   * Checks if the page type is `BitmapPage`.
-   * @param page Page data
-   * @returns boolean indicating if the page type is `BitmapPage`
+   * You register a post-processing function which is called after the callback function of the `trigger` method finishes.
+   * This function receives the value returned by the `trigger` method's callback function as a parameter.
+   * If you register multiple post-processing functions, they are executed in order, with each function receiving the value returned by the previous one as a parameter.
+   * @param command Command to work.
+   * @param callback Post-preprocessing function to register.
    */
-  isBitmapPage(page) {
-    return _BitmapPageManager.IsBitmapPage(page);
+  onAfter(command, callback) {
+    this._on(this.afterHooks, command, callback, -1);
+    return this;
   }
   /**
-   * Checks if a page is empty.
-   * @param page Page data
-   * @param index Bitmap index
-   * @returns boolean indicating if the page is empty
+   * Similar to the `onAfter` method, but it only runs once.
+   * For more details, please refer to the `onAfter` method.
+   * @param command Command to work.
+   * @param callback Post-preprocessing function to register.
    */
-  isEmptyPage(page, index) {
-    return bytesToNumber(page, index, 1) === 0;
+  onceAfter(command, callback) {
+    this._on(this.afterHooks, command, callback, 1);
+    return this;
+  }
+  _off(hooks, command, callback) {
+    const wrappers = this._ensureCommand(hooks, command);
+    if (callback) {
+      const i = wrappers.findIndex((wrapper) => wrapper.callback === callback);
+      if (i !== -1) {
+        wrappers.splice(i, 1);
+      }
+    } else {
+      wrappers.length = 0;
+    }
+    return this;
   }
   /**
-   * Gets a bit from the bitmap page.
-   * @param page Page data
-   * @param index Bit index
-   * @returns boolean indicating if the bit is set
+   * You remove the preprocessing functions registered with `onBefore` or `onceBefore` methods.
+   * If you don't specify a callback parameter, it removes all preprocessing functions registered for that command.
+   * @param command Commands with preprocessing functions to be deleted.
+   * @param callback Preprocessing function to be deleted.
    */
-  getBit(page, index) {
-    const bitOffset = Math.floor(index / 8);
-    const offset = _BitmapPageManager.CONSTANT.SIZE_PAGE_HEADER + bitOffset;
-    const value = bytesToNumber(page, offset, 1);
-    return getBit(value, index % 8);
+  offBefore(command, callback) {
+    this._off(this.beforeHooks, command, callback);
+    return this;
   }
   /**
-   * Sets a bit in the bitmap page.
-   * @param page Page data
-   * @param index Bit index
-   * @param flag boolean indicating if the bit is set
+   * You remove the post-preprocessing functions registered with `onAfter` or `onceAfter` methods.
+   * If you don't specify a callback parameter, it removes all post-preprocessing functions registered for that command.
+   * @param command Commands with post-preprocessing functions to be deleted.
+   * @param callback post-Preprocessing function to be deleted.
    */
-  setBit(page, index, flag) {
-    const bitOffset = Math.floor(index / 8);
-    const offset = _BitmapPageManager.CONSTANT.SIZE_PAGE_HEADER + bitOffset;
-    const value = bytesToNumber(page, offset, 1);
-    const newValue = setBit(value, index % 8, flag);
-    numberToBytes(newValue, page, offset, 1);
+  offAfter(command, callback) {
+    this._off(this.afterHooks, command, callback);
+    return this;
   }
-};
-var OverflowPageManager = class _OverflowPageManager extends PageManager {
-  get pageType() {
-    return PageManager.CONSTANT.PAGE_TYPE_OVERFLOW;
+  async _hookWith(hooks, command, value, ...params) {
+    let wrappers = this._ensureCommand(hooks, command);
+    let i = wrappers.length;
+    while (i--) {
+      const wrapper = wrappers[i];
+      value = await wrapper.callback(value, ...params);
+      wrapper.repeat -= 1;
+      if (wrapper.repeat === 0) {
+        this._off(hooks, command, wrapper.callback);
+      }
+    }
+    return value;
   }
   /**
-   * Checks if the page type is `OverflowPage`.
-   * @param page Page data
-   * @returns boolean indicating if the page type is `OverflowPage`
+   * You execute the callback function provided as a parameter. This callback function receives the 'initialValue' parameter.
+   * 
+   * If preprocessing functions are registered, they run first, and the value returned by the preprocessing functions becomes the 'initialValue' parameter.
+   * After the callback function finishes, post-processing functions are called.
+   * These post-processing functions receive the value returned by the callback function as a parameter and run sequentially.
+   * 
+   * The final value returned becomes the result of the `trigger` method.
+   * @param command Command to work.
+   * @param initialValue Initial value to be passed to the callback function.
+   * @param callback The callback function to be executed.
    */
-  static IsOverflowPage(page) {
-    return PageManager.GetPageType(page) === PageManager.CONSTANT.PAGE_TYPE_OVERFLOW;
+  async trigger(command, initialValue, callback, ...params) {
+    let value;
+    value = await this._hookWith(this.beforeHooks, command, initialValue, ...params);
+    value = await callback(value, ...params);
+    value = await this._hookWith(this.afterHooks, command, value, ...params);
+    return value;
   }
-  /**
-   * Checks if the page type is `OverflowPage`.
-   * @param page Page data
-   * @returns boolean indicating if the page type is `OverflowPage`
-   */
-  isOverflowPage(page) {
-    return _OverflowPageManager.IsOverflowPage(page);
+};
+function useHookall(target = Hookall.Global) {
+  return new Hookall(target);
+}
+var HookallStore2 = class extends WeakMap {
+  ensure(obj, key) {
+    if (!this.has(obj)) {
+      const scope2 = {};
+      this.set(obj, scope2);
+    }
+    const scope = this.get(obj);
+    if (!Object.prototype.hasOwnProperty.call(scope, key)) {
+      scope[key] = /* @__PURE__ */ new Map();
+    }
+    return scope[key];
   }
 };
-var UnknownPageManager = class _UnknownPageManager extends PageManager {
-  get pageType() {
-    return PageManager.CONSTANT.PAGE_TYPE_UNKNOWN;
-  }
+var HookallSync = class _HookallSync {
+  static Global = {};
+  static _Store = new HookallStore2();
+  beforeHooks;
+  afterHooks;
   /**
-   * Checks if the page type is `UnknownPage`.
-   * @param page Page data
-   * @returns boolean indicating if the page type is `UnknownPage`
+   * Create hook system. you can pass a target object or undefined.
+   * If you pass a object, the hook system will be work for object locally. You're going to want this kind of usage in general.
+   * If not specified, will be work for global. This is useful when you want to share your work with multiple files.
+   * @param target The object to work with locally. If not specified, will be work for global.
    */
-  static IsUnknownPage(page) {
-    return PageManager.GetPageType(page) === PageManager.CONSTANT.PAGE_TYPE_UNKNOWN;
+  constructor(target) {
+    this.beforeHooks = _HookallSync._Store.ensure(target, "before");
+    this.afterHooks = _HookallSync._Store.ensure(target, "after");
   }
-  /**
-   * Checks if the page is `UnknownPage`.
-   * @param page Page data
-   * @returns `true` if the page is `UnknownPage`, otherwise `false`
-   */
-  isUnknownPage(page) {
-    return _UnknownPageManager.IsUnknownPage(page);
+  _ensureCommand(hooks, command) {
+    if (!hooks.has(command)) {
+      hooks.set(command, []);
+    }
+    return hooks.get(command);
   }
-};
-var PageManagerFactory = class _PageManagerFactory {
-  static EmptyPage = new EmptyPageManager();
-  static DataPage = new DataPageManager();
-  static IndexPage = new IndexPageManager();
-  static MetadataPage = new MetadataPageManager();
-  static BitmapPage = new BitmapPageManager();
-  static OverflowPage = new OverflowPageManager();
-  static UnknownPage = new UnknownPageManager();
-  /**
-   * Returns the page type.
-   * @param page Page data
-   * @returns Page type
-   */
-  getPageType(page) {
-    return bytesToNumber(page, PageManager.CONSTANT.OFFSET_PAGE_TYPE, PageManager.CONSTANT.SIZE_PAGE_TYPE);
+  _createWrapper(command, callback, repeat) {
+    return {
+      callback,
+      command,
+      repeat
+    };
   }
-  /**
-   * Checks if the page is `EmptyPage`.
-   * @param page Page data
-   * @returns `true` if the page is `EmptyPage`, otherwise `false`
-   */
-  isEmptyPage(page) {
-    return EmptyPageManager.IsEmptyPage(page);
+  _on(hooks, command, callback, repeat) {
+    const wrappers = this._ensureCommand(hooks, command);
+    const wrapper = this._createWrapper(command, callback, repeat);
+    wrappers.unshift(wrapper);
   }
   /**
-   * Checks if the page is `DataPage`.
-   * @param page Page data
-   * @returns `true` if the page is `DataPage`, otherwise `false`
+   * You register a preprocessing function, which is called before the callback function of the `trigger` method.
+   * The value returned by this function is passed as a parameter to the `trigger` method's callback function.
+   * If you register multiple preprocessing functions, they are executed in order, with each function receiving the value returned by the previous one as a parameter.
+   * @param command Command to work.
+   * @param callback Preprocessing function to register.
    */
-  isDataPage(page) {
-    return DataPageManager.IsDataPage(page);
+  onBefore(command, callback) {
+    this._on(this.beforeHooks, command, callback, -1);
+    return this;
   }
   /**
-   * Checks if the page is `IndexPage`.
-   * @param page Page data
-   * @returns `true` if the page is `IndexPage`, otherwise `false`
+   * Similar to the `onBefore` method, but it only runs once.
+   * For more details, please refer to the `onBefore` method.
+   * @param command Command to work.
+   * @param callback Preprocessing function to register.
    */
-  isIndexPage(page) {
-    return IndexPageManager.IsIndexPage(page);
+  onceBefore(command, callback) {
+    this._on(this.beforeHooks, command, callback, 1);
+    return this;
   }
   /**
-   * Checks if the page is `MetadataPage`.
-   * @param page Page data
-   * @returns `true` if the page is `MetadataPage`, otherwise `false`
+   * You register a post-processing function which is called after the callback function of the `trigger` method finishes.
+   * This function receives the value returned by the `trigger` method's callback function as a parameter.
+   * If you register multiple post-processing functions, they are executed in order, with each function receiving the value returned by the previous one as a parameter.
+   * @param command Command to work.
+   * @param callback Post-preprocessing function to register.
    */
-  isMetadataPage(page) {
-    return MetadataPageManager.IsMetadataPage(page);
+  onAfter(command, callback) {
+    this._on(this.afterHooks, command, callback, -1);
+    return this;
   }
   /**
-   * Checks if the page is `BitmapPage`.
-   * @param page Page data
-   * @returns `true` if the page is `BitmapPage`, otherwise `false`
+   * Similar to the `onAfter` method, but it only runs once.
+   * For more details, please refer to the `onAfter` method.
+   * @param command Command to work.
+   * @param callback Post-preprocessing function to register.
    */
-  isBitmapPage(page) {
-    return BitmapPageManager.IsBitmapPage(page);
+  onceAfter(command, callback) {
+    this._on(this.afterHooks, command, callback, 1);
+    return this;
+  }
+  _off(hooks, command, callback) {
+    const wrappers = this._ensureCommand(hooks, command);
+    if (callback) {
+      const i = wrappers.findIndex((wrapper) => wrapper.callback === callback);
+      if (i !== -1) {
+        wrappers.splice(i, 1);
+      }
+    } else {
+      wrappers.length = 0;
+    }
+    return this;
   }
   /**
-   * Checks if the page is `OverflowPage`.
-   * @param page Page data
-   * @returns `true` if the page is `OverflowPage`, otherwise `false`
+   * You remove the preprocessing functions registered with `onBefore` or `onceBefore` methods.
+   * If you don't specify a callback parameter, it removes all preprocessing functions registered for that command.
+   * @param command Commands with preprocessing functions to be deleted.
+   * @param callback Preprocessing function to be deleted.
    */
-  isOverflowPage(page) {
-    return OverflowPageManager.IsOverflowPage(page);
+  offBefore(command, callback) {
+    this._off(this.beforeHooks, command, callback);
+    return this;
   }
   /**
-   * Checks if the page is `UnknownPage`.
-   * @param page Page data
-   * @returns `true` if the page is `UnknownPage`, otherwise `false`
+   * You remove the post-preprocessing functions registered with `onAfter` or `onceAfter` methods.
+   * If you don't specify a callback parameter, it removes all post-preprocessing functions registered for that command.
+   * @param command Commands with post-preprocessing functions to be deleted.
+   * @param callback post-Preprocessing function to be deleted.
    */
-  isUnknownPage(page) {
-    return UnknownPageManager.IsUnknownPage(page);
+  offAfter(command, callback) {
+    this._off(this.afterHooks, command, callback);
+    return this;
   }
-  getManager(page) {
-    switch (this.getPageType(page)) {
-      case PageManager.CONSTANT.PAGE_TYPE_EMPTY:
-        return _PageManagerFactory.EmptyPage;
-      case PageManager.CONSTANT.PAGE_TYPE_METADATA:
-        return _PageManagerFactory.MetadataPage;
-      case PageManager.CONSTANT.PAGE_TYPE_BITMAP:
-        return _PageManagerFactory.BitmapPage;
-      case PageManager.CONSTANT.PAGE_TYPE_INDEX:
-        return _PageManagerFactory.IndexPage;
-      case PageManager.CONSTANT.PAGE_TYPE_DATA:
-        return _PageManagerFactory.DataPage;
-      case PageManager.CONSTANT.PAGE_TYPE_OVERFLOW:
-        return _PageManagerFactory.OverflowPage;
-      case PageManager.CONSTANT.PAGE_TYPE_UNKNOWN:
-        return _PageManagerFactory.UnknownPage;
-      default:
-        throw new Error(`Invalid page type: ${this.getPageType(page)}`);
+  _hookWith(hooks, command, value, ...params) {
+    let wrappers = this._ensureCommand(hooks, command);
+    let i = wrappers.length;
+    while (i--) {
+      const wrapper = wrappers[i];
+      value = wrapper.callback(value, ...params);
+      wrapper.repeat -= 1;
+      if (wrapper.repeat === 0) {
+        this._off(hooks, command, wrapper.callback);
+      }
     }
+    return value;
   }
-  getManagerFromType(pageType) {
-    switch (pageType) {
-      case PageManager.CONSTANT.PAGE_TYPE_EMPTY:
-        return _PageManagerFactory.EmptyPage;
-      case PageManager.CONSTANT.PAGE_TYPE_METADATA:
-        return _PageManagerFactory.MetadataPage;
-      case PageManager.CONSTANT.PAGE_TYPE_BITMAP:
-        return _PageManagerFactory.BitmapPage;
-      case PageManager.CONSTANT.PAGE_TYPE_INDEX:
-        return _PageManagerFactory.IndexPage;
-      case PageManager.CONSTANT.PAGE_TYPE_DATA:
-        return _PageManagerFactory.DataPage;
-      case PageManager.CONSTANT.PAGE_TYPE_OVERFLOW:
-        return _PageManagerFactory.OverflowPage;
-      case PageManager.CONSTANT.PAGE_TYPE_UNKNOWN:
-        return _PageManagerFactory.UnknownPage;
-      default:
-        throw new Error(`Invalid page type: ${pageType}`);
-    }
+  /**
+   * You execute the callback function provided as a parameter. This callback function receives the 'initialValue' parameter.
+   * 
+   * If preprocessing functions are registered, they run first, and the value returned by the preprocessing functions becomes the 'initialValue' parameter.
+   * After the callback function finishes, post-processing functions are called.
+   * These post-processing functions receive the value returned by the callback function as a parameter and run sequentially.
+   * 
+   * The final value returned becomes the result of the `trigger` method.
+   * @param command Command to work.
+   * @param initialValue Initial value to be passed to the callback function.
+   * @param callback The callback function to be executed.
+   */
+  trigger(command, initialValue, callback, ...params) {
+    let value;
+    value = this._hookWith(this.beforeHooks, command, initialValue, ...params);
+    value = callback(value, ...params);
+    value = this._hookWith(this.afterHooks, command, value, ...params);
+    return value;
   }
 };
 
@@ -5714,7 +5720,7 @@ var RowTableEngine = class {
    * @param tx Transaction
    * @returns PK of the inserted data
    */
-  async insert(data, incrementRowCount, tx) {
+  async insert(data, incrementRowCount, overflowForcly, tx) {
     await tx.__acquireWriteLock(0);
     const metadataPage = await this.pfs.getMetadata(tx);
     const pk = this.metadataPageManager.getLastRowPk(metadataPage) + 1;
@@ -5724,7 +5730,7 @@ var RowTableEngine = class {
       throw new Error(`Last insert page is not data page`);
     }
     const willRowSize = this.getRequiredRowSize(data);
-    if (willRowSize > this.maxBodySize) {
+    if (willRowSize > this.maxBodySize || overflowForcly) {
       const overflowPageId = await this.pfs.appendNewPage(this.overflowPageManager.pageType, tx);
       const row = new Uint8Array(Row.CONSTANT.SIZE_HEADER + 4);
       this.rowManager.setPK(row, pk);
@@ -6209,11 +6215,9 @@ var Transaction = class {
 var DataplyAPI = class {
   constructor(file, options) {
     this.file = file;
-    this.hook = {
-      sync: useHookallSync(this),
-      async: useHookall(this)
-    };
+    this.hook = useHookall(this);
     this.options = this.verboseOptions(options);
+    this.isNewlyCreated = !import_node_fs3.default.existsSync(file);
     this.fileHandle = this.createOrOpen(file, this.options);
     this.pfs = new PageFileSystem(
       this.fileHandle,
@@ -6227,14 +6231,28 @@ var DataplyAPI = class {
     this.initialized = false;
     this.txIdCounter = 0;
   }
+  /**
+   * These are not the same options that were used when the database was created.
+   * They are simply the options received when the instance was created.
+   * If you want to retrieve the options used during database creation, use `getMetadata()` instead.
+   */
   options;
+  /** File handle. Database file descriptor */
   fileHandle;
+  /** Page file system. Used for managing pages. If you know what it is, you can skip this. */
   pfs;
+  /** Row table engine. Used for managing rows. If you know what it is, you can skip this. */
   rowTableEngine;
+  /** Lock manager. Used for managing transactions */
   lockManager;
+  /** Text codec. Used for encoding and decoding text data */
   textCodec;
+  /** Hook */
   hook;
+  /** Whether the database was initialized via `init()` */
   initialized;
+  /** Whether the database was created this time. */
+  isNewlyCreated;
   txIdCounter;
   /**
    * Verifies if the page file is a valid Dataply file.
@@ -6271,47 +6289,45 @@ var DataplyAPI = class {
    * @param fileHandle File handle
    */
   initializeFile(file, fileHandle, options) {
-    this.hook.sync.trigger("create", void 0, () => {
-      const metadataPageManager = new MetadataPageManager();
-      const bitmapPageManager = new BitmapPageManager();
-      const dataPageManager = new DataPageManager();
-      const metadataPage = new Uint8Array(options.pageSize);
-      const dataPage = new Uint8Array(options.pageSize);
-      metadataPageManager.initial(
-        metadataPage,
-        MetadataPageManager.CONSTANT.PAGE_TYPE_METADATA,
-        0,
-        0,
-        options.pageSize - MetadataPageManager.CONSTANT.SIZE_PAGE_HEADER
-      );
-      metadataPageManager.setMagicString(metadataPage);
-      metadataPageManager.setPageSize(metadataPage, options.pageSize);
-      metadataPageManager.setRootIndexPageId(metadataPage, -1);
-      metadataPageManager.setBitmapPageId(metadataPage, 1);
-      metadataPageManager.setLastInsertPageId(metadataPage, 2);
-      metadataPageManager.setPageCount(metadataPage, 3);
-      metadataPageManager.setFreePageId(metadataPage, -1);
-      const bitmapPage = new Uint8Array(options.pageSize);
-      bitmapPageManager.initial(
-        bitmapPage,
-        BitmapPageManager.CONSTANT.PAGE_TYPE_BITMAP,
-        1,
-        -1,
-        options.pageSize - BitmapPageManager.CONSTANT.SIZE_PAGE_HEADER
-      );
-      dataPageManager.initial(
-        dataPage,
-        DataPageManager.CONSTANT.PAGE_TYPE_DATA,
-        2,
-        -1,
-        options.pageSize - DataPageManager.CONSTANT.SIZE_PAGE_HEADER
-      );
-      import_node_fs3.default.appendFileSync(fileHandle, new Uint8Array([
-        ...metadataPage,
-        ...bitmapPage,
-        ...dataPage
-      ]));
-    }, file, fileHandle, options);
+    const metadataPageManager = new MetadataPageManager();
+    const bitmapPageManager = new BitmapPageManager();
+    const dataPageManager = new DataPageManager();
+    const metadataPage = new Uint8Array(options.pageSize);
+    const dataPage = new Uint8Array(options.pageSize);
+    metadataPageManager.initial(
+      metadataPage,
+      MetadataPageManager.CONSTANT.PAGE_TYPE_METADATA,
+      0,
+      0,
+      options.pageSize - MetadataPageManager.CONSTANT.SIZE_PAGE_HEADER
+    );
+    metadataPageManager.setMagicString(metadataPage);
+    metadataPageManager.setPageSize(metadataPage, options.pageSize);
+    metadataPageManager.setRootIndexPageId(metadataPage, -1);
+    metadataPageManager.setBitmapPageId(metadataPage, 1);
+    metadataPageManager.setLastInsertPageId(metadataPage, 2);
+    metadataPageManager.setPageCount(metadataPage, 3);
+    metadataPageManager.setFreePageId(metadataPage, -1);
+    const bitmapPage = new Uint8Array(options.pageSize);
+    bitmapPageManager.initial(
+      bitmapPage,
+      BitmapPageManager.CONSTANT.PAGE_TYPE_BITMAP,
+      1,
+      -1,
+      options.pageSize - BitmapPageManager.CONSTANT.SIZE_PAGE_HEADER
+    );
+    dataPageManager.initial(
+      dataPage,
+      DataPageManager.CONSTANT.PAGE_TYPE_DATA,
+      2,
+      -1,
+      options.pageSize - DataPageManager.CONSTANT.SIZE_PAGE_HEADER
+    );
+    import_node_fs3.default.appendFileSync(fileHandle, new Uint8Array([
+      ...metadataPage,
+      ...bitmapPage,
+      ...dataPage
+    ]));
   }
   /**
    * Opens the database file. If the file does not exist, it initializes it.
@@ -6358,11 +6374,12 @@ var DataplyAPI = class {
     if (this.initialized) {
       return;
     }
-    await this.runWithDefault(() => {
-      return this.hook.async.trigger("init", void 0, async () => {
+    await this.runWithDefault(async (tx) => {
+      await this.hook.trigger("init", tx, async (tx2) => {
         await this.rowTableEngine.init();
         this.initialized = true;
-      });
+        return tx2;
+      }, this.isNewlyCreated);
     });
   }
   /**
@@ -6426,7 +6443,26 @@ var DataplyAPI = class {
       if (typeof data === "string") {
         data = this.textCodec.encode(data);
       }
-      return this.rowTableEngine.insert(data, incrementRowCount, tx2);
+      return this.rowTableEngine.insert(data, incrementRowCount, false, tx2);
+    }, tx);
+  }
+  /**
+   * Inserts overflow data forcly. Returns the PK of the added row.
+   * @param data Data to add
+   * @param incrementRowCount Whether to increment the row count to metadata
+   * @param tx Transaction
+   * @returns PK of the added data
+   */
+  async insertAsOverflow(data, incrementRowCount, tx) {
+    if (!this.initialized) {
+      throw new Error("Dataply instance is not initialized");
+    }
+    return this.runWithDefault((tx2) => {
+      incrementRowCount = incrementRowCount ?? true;
+      if (typeof data === "string") {
+        data = this.textCodec.encode(data);
+      }
+      return this.rowTableEngine.insert(data, incrementRowCount, true, tx2);
     }, tx);
   }
   /**
@@ -6446,7 +6482,7 @@ var DataplyAPI = class {
       const pks = [];
       for (const data of dataList) {
         const encoded = typeof data === "string" ? this.textCodec.encode(data) : data;
-        const pk = await this.rowTableEngine.insert(encoded, incrementRowCount, tx2);
+        const pk = await this.rowTableEngine.insert(encoded, incrementRowCount, false, tx2);
         pks.push(pk);
       }
       return pks;
@@ -6502,7 +6538,7 @@ var DataplyAPI = class {
     if (!this.initialized) {
       throw new Error("Dataply instance is not initialized");
     }
-    return this.hook.async.trigger("close", void 0, async () => {
+    return this.hook.trigger("close", void 0, async () => {
       await this.pfs.close();
       import_node_fs3.default.closeSync(this.fileHandle);
     });
@@ -6642,20 +6678,29 @@ var GlobalTransaction = class {
 0 && (module.exports = {
   BPTreeAsync,
   BPTreeSync,
+  BitmapPageManager,
   CacheEntanglementAsync,
   CacheEntanglementSync,
+  DataPageManager,
   Dataply,
   DataplyAPI,
+  EmptyPageManager,
   GlobalTransaction,
   InMemoryStoreStrategyAsync,
   InMemoryStoreStrategySync,
+  IndexPageManager,
   InvertedWeakMap,
   LRUMap,
+  MetadataPageManager,
   NumericComparator,
+  OverflowPageManager,
+  PageManager,
+  PageManagerFactory,
   Ryoiki,
   SerializeStrategyAsync,
   SerializeStrategySync,
   StringComparator,
   Transaction,
+  UnknownPageManager,
   ValueComparator
 });