dataply 0.0.26-alpha.5 → 0.0.26-alpha.6

package/dist/cjs/index.js

@@ -9553,45 +9553,27 @@ var WALManager = class {
 
 // src/core/PageMVCCStrategy.ts
 var import_node_fs2 = __toESM(require("node:fs"));
-var PageMVCCStrategy = class {
-  constructor(fileHandle, pageSize, cacheCapacity) {
+var PageMVCCStrategy = class extends AsyncMVCCStrategy2 {
+  constructor(fileHandle, pageSize) {
+    super();
     this.fileHandle = fileHandle;
     this.pageSize = pageSize;
-    this.cache = new LRUMap2(cacheCapacity);
     this.fileSize = import_node_fs2.default.fstatSync(fileHandle).size;
   }
-  /** LRU 캐시 (페이지 ID -> 페이지 데이터) */
-  cache;
-  /** 디스크에 기록되지 않은 변경된 페이지들 (페이지 ID -> 페이지 데이터) */
-  dirtyPages = /* @__PURE__ */ new Map();
   /** 파일 크기 (논리적) */
   fileSize;
   /**
    * 디스크에서 페이지를 읽습니다.
-   * 캐시에 있으면 캐시에서 반환합니다.
    * @param pageId 페이지 ID
    * @returns 페이지 데이터
    */
   async read(pageId) {
-    const dirty = this.dirtyPages.get(pageId);
-    if (dirty) {
-      const copy = new Uint8Array(this.pageSize);
-      copy.set(dirty);
-      return copy;
-    }
-    const cached = this.cache.get(pageId);
-    if (cached) {
-      return cached;
-    }
     const buffer = new Uint8Array(this.pageSize);
     const pageStartPos = pageId * this.pageSize;
     if (pageStartPos >= this.fileSize) {
       return buffer;
     }
     await this._readFromDisk(buffer, pageStartPos);
-    const cacheCopy = new Uint8Array(this.pageSize);
-    cacheCopy.set(buffer);
-    this.cache.set(pageId, cacheCopy);
     return buffer;
   }
   /**
@@ -9601,47 +9583,27 @@ var PageMVCCStrategy = class {
    */
   async write(pageId, data) {
     const pageStartPos = pageId * this.pageSize;
-    const dataCopy = new Uint8Array(this.pageSize);
-    dataCopy.set(data);
-    this.dirtyPages.set(pageId, dataCopy);
-    this.cache.set(pageId, dataCopy);
+    await this._writeToDisk(data, pageStartPos);
     const endPosition = pageStartPos + this.pageSize;
     if (endPosition > this.fileSize) {
       this.fileSize = endPosition;
     }
   }
   /**
-   * 더티 페이지들을 메인 디스크 파일에 일괄 기록합니다.
-   * WAL 체크포인트 시점에 호출되어야 합니다.
+   * 페이지 삭제.
+   * 실제 페이지 해제는 상위 레이어(FreeList)에서 관리합니다.
+   * @param pageId 페이지 ID
    */
-  async flush() {
-    if (this.dirtyPages.size === 0) {
-      return;
-    }
-    const snapshot = new Map(this.dirtyPages);
-    const sortedPageIds = Array.from(snapshot.keys()).sort((a, b) => a - b);
-    for (const pageId of sortedPageIds) {
-      const data = snapshot.get(pageId);
-      const position = pageId * this.pageSize;
-      await this._writeToDisk(data, position);
-      this.dirtyPages.delete(pageId);
-    }
+  async delete(pageId) {
   }
   /**
-   * 지정된 페이지들만 디스크에 기록합니다.
-   * WAL 없이 트랜잭션 커밋 시, 해당 트랜잭션의 dirty pages만 선택적으로 flush합니다.
-   * @param pages 기록할 페이지 맵 (PageID -> PageData)
+   * 페이지 존재 여부 확인
+   * @param pageId 페이지 ID
+   * @returns 존재하면 true
    */
-  async flushPages(pages) {
-    if (pages.size === 0) {
-      return;
-    }
-    const sortedPageIds = Array.from(pages.keys()).sort((a, b) => a - b);
-    for (const pageId of sortedPageIds) {
-      const data = pages.get(pageId);
-      const position = pageId * this.pageSize;
-      await this._writeToDisk(data, position);
-    }
+  async exists(pageId) {
+    const pageStartPos = pageId * this.pageSize;
+    return pageStartPos < this.fileSize;
   }
   /**
    * 메인 DB 파일의 물리적 동기화를 수행합니다 (fsync).
@@ -9654,39 +9616,12 @@ var PageMVCCStrategy = class {
       });
     });
   }
-  /**
-   * 페이지 삭제 (실제로는 캐시에서만 제거)
-   * 실제 페이지 해제는 상위 레이어(FreeList)에서 관리합니다.
-   * @param pageId 페이지 ID
-   */
-  async delete(pageId) {
-    this.dirtyPages.delete(pageId);
-    this.cache.delete(pageId);
-  }
-  /**
-   * 페이지 존재 여부 확인
-   * @param pageId 페이지 ID
-   * @returns 존재하면 true
-   */
-  async exists(pageId) {
-    if (this.dirtyPages.has(pageId)) {
-      return true;
-    }
-    const pageStartPos = pageId * this.pageSize;
-    return pageStartPos < this.fileSize;
-  }
   /**
    * 현재 파일 크기 반환
    */
   getFileSize() {
     return this.fileSize;
   }
-  /**
-   * 캐시 초기화
-   */
-  clearCache() {
-    this.cache.clear();
-  }
   // ─────────────────────────────────────────────────────────────
   // Private helpers
   // ─────────────────────────────────────────────────────────────
@@ -9722,13 +9657,15 @@ var PageFileSystem = class {
     const walPath = options.wal;
     this.walManager = walPath && walLogger ? new WALManager(walPath, pageSize, walLogger) : null;
     this.pageManagerFactory = new PageManagerFactory();
-    this.pageStrategy = new PageMVCCStrategy(fileHandle, pageSize, pageCacheCapacity);
+    this.pageStrategy = new PageMVCCStrategy(fileHandle, pageSize);
+    this.rootTransaction = new AsyncMVCCTransaction2(this.pageStrategy, { cacheCapacity: pageCacheCapacity });
     this.logger = logger;
   }
   pageFactory = new PageManagerFactory();
   walManager;
   pageManagerFactory;
   pageStrategy;
+  rootTransaction;
   logger;
   /** 글로벌 동기화(체크포인트/커밋)를 위한 Mutex */
   lockPromise = Promise.resolve();
@@ -9769,6 +9706,12 @@ var PageFileSystem = class {
   getPageStrategy() {
     return this.pageStrategy;
   }
+  /**
+   * Returns the root MVCC transaction.
+   */
+  getRootTransaction() {
+    return this.rootTransaction;
+  }
   /**
    * Updates the bitmap status for a specific page.
    * @param pageId The ID of the page to update
@@ -10066,27 +10009,14 @@ var PageFileSystem = class {
     metadataManager.setFreePageId(metadata, pageId);
     await this.setPage(0, metadata, tx);
   }
-  /**
-   * WAL에 커밋합니다.
-   * @param dirtyPages 변경된 페이지들
-   */
-  async commitToWAL(dirtyPages) {
-    if (this.walManager) {
-      this.logger.debug(`Committing ${dirtyPages.size} pages to WAL`);
-      await this.walManager.prepareCommit(dirtyPages);
-      await this.walManager.finalizeCommit(true);
-    }
-  }
   /**
    * 체크포인트를 수행합니다.
-   * 1. 메모리의 더티 페이지를 DB 파일에 기록 (Flush)
-   * 2. DB 파일 물리적 동기화 (Sync/fsync)
-   * 3. WAL 로그 파일 비우기 (Clear/Truncate)
+   * 1. DB 파일 물리적 동기화 (Sync/fsync)
+   * 2. WAL 로그 파일 비우기 (Clear/Truncate)
    */
   async checkpoint() {
     this.logger.info("Starting checkpoint");
     await this.runGlobalLock(async () => {
-      await this.pageStrategy.flush();
       await this.pageStrategy.sync();
       if (this.walManager) {
         await this.walManager.clear();
@@ -10891,17 +10821,16 @@ var Transaction = class {
   /**
    * @param id Transaction ID
    * @param context Transaction context
-   * @param pageStrategy Page MVCC Strategy for disk I/O
+   * @param rootTx Root MVCC Transaction
    * @param lockManager LockManager instance
    * @param pfs Page File System
-   * @param reloadBPTree Callback to reload BPTree cache on rollback
    */
-  constructor(id, context, pageStrategy, lockManager, pfs) {
+  constructor(id, context, rootTx, lockManager, pfs) {
     this.context = context;
     this.lockManager = lockManager;
     this.pfs = pfs;
     this.id = id;
-    this.pageStrategy = pageStrategy;
+    this.rootTx = rootTx;
   }
   /** Transaction ID */
   id;
@@ -10909,16 +10838,25 @@ var Transaction = class {
   heldLocks = /* @__PURE__ */ new Set();
   /** Held page locks (PageID -> LockID) */
   pageLocks = /* @__PURE__ */ new Map();
-  /** Dirty Pages modified by the transaction: PageID -> Modified Page Buffer */
-  dirtyPages = /* @__PURE__ */ new Map();
-  /** Undo pages: PageID -> Original Page Buffer (Snapshot) */
-  undoPages = /* @__PURE__ */ new Map();
   /** List of callbacks to execute on commit */
   commitHooks = [];
-  /** Page MVCC Strategy for disk access */
-  pageStrategy;
+  /** Nested MVCC Transaction for snapshot isolation (lazy init) */
+  mvccTx = null;
+  /** Root MVCC Transaction reference */
+  rootTx;
   /** Release function for global write lock, set by DataplyAPI */
   _writeLockRelease = null;
+  /**
+   * Lazily initializes the nested MVCC transaction.
+   * This ensures the snapshot is taken at the time of first access,
+   * picking up the latest committed root version.
+   */
+  ensureMvccTx() {
+    if (!this.mvccTx) {
+      this.mvccTx = this.rootTx.createNested();
+    }
+    return this.mvccTx;
+  }
   /**
    * Registers a commit hook.
    * @param hook Function to execute
@@ -10940,30 +10878,35 @@ var Transaction = class {
     return this._writeLockRelease !== null;
   }
   /**
-   * Reads a page. Uses dirty buffer if available, otherwise disk.
+   * Reads a page through the MVCC transaction.
    * @param pageId Page ID
    * @returns Page data
    */
   async readPage(pageId) {
-    const dirty = this.dirtyPages.get(pageId);
-    if (dirty) {
-      return dirty;
+    const tx = this.ensureMvccTx();
+    const data = await tx.read(pageId);
+    if (data === null) {
+      return new Uint8Array(this.pfs.pageSize);
     }
-    return await this.pageStrategy.read(pageId);
+    const copy = new Uint8Array(data.length);
+    copy.set(data);
+    return copy;
   }
   /**
-   * Writes a page to the transaction buffer.
+   * Writes a page through the MVCC transaction.
    * @param pageId Page ID
    * @param data Page data
    */
   async writePage(pageId, data) {
-    if (!this.undoPages.has(pageId)) {
-      const existingData = await this.pageStrategy.read(pageId);
-      const snapshot = new Uint8Array(existingData.length);
-      snapshot.set(existingData);
-      this.undoPages.set(pageId, snapshot);
+    const tx = this.ensureMvccTx();
+    const exists = await tx.exists(pageId);
+    if (exists) {
+      const copy = new Uint8Array(data.length);
+      copy.set(data);
+      await tx.write(pageId, copy);
+    } else {
+      await tx.create(pageId, data);
     }
-    this.dirtyPages.set(pageId, data);
   }
   /**
    * Acquires a write lock.
@@ -10990,21 +10933,31 @@ var Transaction = class {
           await hook();
         }
       });
+      const tx = this.ensureMvccTx();
       let shouldTriggerCheckpoint = false;
       await this.pfs.runGlobalLock(async () => {
-        if (this.pfs.wal && this.dirtyPages.size > 0) {
-          await this.pfs.wal.prepareCommit(this.dirtyPages);
+        const entries = tx.getResultEntries();
+        const dirtyPages = /* @__PURE__ */ new Map();
+        for (const entry of [...entries.created, ...entries.updated]) {
+          dirtyPages.set(entry.key, entry.data);
+        }
+        const hasDirtyPages = dirtyPages.size > 0;
+        if (this.pfs.wal && hasDirtyPages) {
+          await this.pfs.wal.prepareCommit(dirtyPages);
           await this.pfs.wal.writeCommitMarker();
         }
-        for (const [pageId, data] of this.dirtyPages) {
-          await this.pageStrategy.write(pageId, data);
+        await tx.commit();
+        if (hasDirtyPages) {
+          await this.rootTx.commit();
         }
-        if (!this.pfs.wal) {
-          await this.pfs.strategy.flushPages(this.dirtyPages);
-        } else {
-          this.pfs.wal.incrementWrittenPages(this.dirtyPages.size);
-          if (this.pfs.wal.shouldCheckpoint(this.pfs.options.walCheckpointThreshold)) {
-            shouldTriggerCheckpoint = true;
+        if (hasDirtyPages) {
+          if (!this.pfs.wal) {
+            await this.pfs.strategy.sync();
+          } else {
+            this.pfs.wal.incrementWrittenPages(dirtyPages.size);
+            if (this.pfs.wal.shouldCheckpoint(this.pfs.options.walCheckpointThreshold)) {
+              shouldTriggerCheckpoint = true;
+            }
           }
         }
       });
@@ -11012,8 +10965,6 @@ var Transaction = class {
         await this.pfs.checkpoint();
       }
     } finally {
-      this.dirtyPages.clear();
-      this.undoPages.clear();
       this.releaseAllLocks();
       if (this._writeLockRelease) {
         this._writeLockRelease();
@@ -11026,8 +10977,9 @@ var Transaction = class {
    */
   async rollback() {
     try {
-      this.dirtyPages.clear();
-      this.undoPages.clear();
+      if (this.mvccTx) {
+        this.mvccTx.rollback();
+      }
       this.releaseAllLocks();
     } finally {
       if (this._writeLockRelease) {
@@ -11036,12 +10988,6 @@ var Transaction = class {
       }
     }
   }
-  /**
-   * Returns the dirty pages map.
-   */
-  __getDirtyPages() {
-    return this.dirtyPages;
-  }
   /**
    * Releases all locks.
    */
@@ -11133,6 +11079,7 @@ var DataplyAPI = class {
   constructor(file, options) {
     this.file = file;
     this.hook = useHookall(this);
+    this.latcher = new Ryoiki3();
     this.options = this.verboseOptions(options);
     this.loggerManager = new LoggerManager(this.options.logLevel);
     this.logger = this.loggerManager.create("DataplyAPI");
@@ -11185,6 +11132,38 @@ var DataplyAPI = class {
   txIdCounter;
   /** Promise-chain mutex for serializing write operations */
   writeQueue = Promise.resolve();
+  /** Lock manager. Used for managing transactions */
+  latcher;
+  /**
+   * Acquire a read lock on the given page ID and execute the given function.
+   * @param pageId Page ID to acquire a read lock on
+   * @param fn Function to execute while holding the read lock
+   * @returns The result of the given function
+   */
+  async latchReadLock(pageId, fn) {
+    let lockId;
+    return this.latcher.readLock(this.latcher.range(pageId, 1), async (_lockId) => {
+      lockId = _lockId;
+      return fn();
+    }).finally(() => {
+      this.latcher.readUnlock(lockId);
+    });
+  }
+  /**
+   * Acquire a write lock on the given page ID and execute the given function.
+   * @param pageId Page ID to acquire a write lock on
+   * @param fn Function to execute while holding the write lock
+   * @returns The result of the given function
+   */
+  async latchWriteLock(pageId, fn) {
+    let lockId;
+    return this.latcher.writeLock(this.latcher.range(pageId, 1), async (_lockId) => {
+      lockId = _lockId;
+      return fn();
+    }).finally(() => {
+      this.latcher.writeUnlock(lockId);
+    });
+  }
   /**
    * Verifies if the page file is a valid Dataply file.
    * The metadata page must be located at the beginning of the Dataply file.
@@ -11213,7 +11192,7 @@ var DataplyAPI = class {
       pagePreallocationCount: 1e3,
       wal: null,
       walCheckpointThreshold: 1e3,
-      logLevel: 2 /* Info */
+      logLevel: 0 /* None */
     }, options);
   }
   /**
@@ -11334,7 +11313,7 @@ var DataplyAPI = class {
     return new Transaction(
       ++this.txIdCounter,
       this.txContext,
-      this.pfs.getPageStrategy(),
+      this.pfs.getRootTransaction(),
       this.lockManager,
       this.pfs
     );
@@ -11354,7 +11333,7 @@ var DataplyAPI = class {
    * Used internally by runWithDefaultWrite.
    * @returns A release function
    */
-  acquireWriteLock() {
+  async acquireWriteLock() {
     this.logger.debug("Acquiring write lock");
     const previous = this.writeQueue;
     let release;

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

@@ -1,5 +1,6 @@
 import { type DataplyOptions, type DataplyMetadata } from '../types';
 import { type IHookall } from 'hookall';
+import { Ryoiki } from 'ryoiki';
 import { PageFileSystem } from './PageFileSystem';
 import { RowTableEngine } from './RowTableEngine';
 import { TextCodec } from '../utils/TextCodec';
@@ -47,7 +48,23 @@ export declare class DataplyAPI {
     private txIdCounter;
     /** Promise-chain mutex for serializing write operations */
     private writeQueue;
+    /** Lock manager. Used for managing transactions */
+    protected readonly latcher: Ryoiki;
     constructor(file: string, options: DataplyOptions);
+    /**
+     * Acquire a read lock on the given page ID and execute the given function.
+     * @param pageId Page ID to acquire a read lock on
+     * @param fn Function to execute while holding the read lock
+     * @returns The result of the given function
+     */
+    latchReadLock<T>(pageId: number, fn: () => Promise<T>): Promise<T>;
+    /**
+     * Acquire a write lock on the given page ID and execute the given function.
+     * @param pageId Page ID to acquire a write lock on
+     * @param fn Function to execute while holding the write lock
+     * @returns The result of the given function
+     */
+    latchWriteLock<T>(pageId: number, fn: () => Promise<T>): Promise<T>;
     /**
      * Verifies if the page file is a valid Dataply file.
      * The metadata page must be located at the beginning of the Dataply file.

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

@@ -1,5 +1,6 @@
 import type { IndexPage, MetadataPage, DataplyOptions } from '../types';
 import type { Transaction } from './transaction/Transaction';
+import { AsyncMVCCTransaction } from 'mvcc-api';
 import { PageManagerFactory } from './Page';
 import { WALManager } from './WALManager';
 import { PageMVCCStrategy } from './PageMVCCStrategy';
@@ -17,6 +18,7 @@ export declare class PageFileSystem {
     protected readonly walManager: WALManager | null;
     protected readonly pageManagerFactory: PageManagerFactory;
     protected readonly pageStrategy: PageMVCCStrategy;
+    protected readonly rootTransaction: AsyncMVCCTransaction<PageMVCCStrategy, number, Uint8Array>;
     protected readonly logger: Logger;
     /** 글로벌 동기화(체크포인트/커밋)를 위한 Mutex */
     private lockPromise;
@@ -39,6 +41,10 @@ export declare class PageFileSystem {
      * Returns the page strategy for transaction use.
      */
     getPageStrategy(): PageMVCCStrategy;
+    /**
+     * Returns the root MVCC transaction.
+     */
+    getRootTransaction(): AsyncMVCCTransaction<PageMVCCStrategy, number, Uint8Array>;
     /**
      * Updates the bitmap status for a specific page.
      * @param pageId The ID of the page to update
@@ -134,16 +140,10 @@ export declare class PageFileSystem {
      * @param tx Transaction
      */
     setFreePage(pageId: number, tx: Transaction): Promise<void>;
-    /**
-     * WAL에 커밋합니다.
-     * @param dirtyPages 변경된 페이지들
-     */
-    commitToWAL(dirtyPages: Map<number, Uint8Array>): Promise<void>;
     /**
      * 체크포인트를 수행합니다.
-     * 1. 메모리의 더티 페이지를 DB 파일에 기록 (Flush)
-     * 2. DB 파일 물리적 동기화 (Sync/fsync)
-     * 3. WAL 로그 파일 비우기 (Clear/Truncate)
+     * 1. DB 파일 물리적 동기화 (Sync/fsync)
+     * 2. WAL 로그 파일 비우기 (Clear/Truncate)
      */
     checkpoint(): Promise<void>;
     /**

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

@@ -1,23 +1,20 @@
+import { AsyncMVCCStrategy } from 'mvcc-api';
 /**
  * 페이지 수준 MVCC Strategy.
  * mvcc-api의 AsyncMVCCStrategy를 상속하여 디스크 I/O를 담당합니다.
+ * 캐시 및 버퍼 관리는 mvcc-api의 AsyncMVCCTransaction이 담당합니다.
  *
  * 키: 페이지 ID (number)
  * 값: 페이지 데이터 (Uint8Array)
  */
-export declare class PageMVCCStrategy {
+export declare class PageMVCCStrategy extends AsyncMVCCStrategy<number, Uint8Array> {
     private readonly fileHandle;
     private readonly pageSize;
-    /** LRU 캐시 (페이지 ID -> 페이지 데이터) */
-    private readonly cache;
-    /** 디스크에 기록되지 않은 변경된 페이지들 (페이지 ID -> 페이지 데이터) */
-    private readonly dirtyPages;
     /** 파일 크기 (논리적) */
     private fileSize;
-    constructor(fileHandle: number, pageSize: number, cacheCapacity: number);
+    constructor(fileHandle: number, pageSize: number);
     /**
      * 디스크에서 페이지를 읽습니다.
-     * 캐시에 있으면 캐시에서 반환합니다.
      * @param pageId 페이지 ID
      * @returns 페이지 데이터
      */
@@ -29,22 +26,7 @@ export declare class PageMVCCStrategy {
      */
     write(pageId: number, data: Uint8Array): Promise<void>;
     /**
-     * 더티 페이지들을 메인 디스크 파일에 일괄 기록합니다.
-     * WAL 체크포인트 시점에 호출되어야 합니다.
-     */
-    flush(): Promise<void>;
-    /**
-     * 지정된 페이지들만 디스크에 기록합니다.
-     * WAL 없이 트랜잭션 커밋 시, 해당 트랜잭션의 dirty pages만 선택적으로 flush합니다.
-     * @param pages 기록할 페이지 맵 (PageID -> PageData)
-     */
-    flushPages(pages: Map<number, Uint8Array>): Promise<void>;
-    /**
-     * 메인 DB 파일의 물리적 동기화를 수행합니다 (fsync).
-     */
-    sync(): Promise<void>;
-    /**
-     * 페이지 삭제 (실제로는 캐시에서만 제거)
+     * 페이지 삭제.
      * 실제 페이지 해제는 상위 레이어(FreeList)에서 관리합니다.
      * @param pageId 페이지 ID
      */
@@ -56,13 +38,13 @@ export declare class PageMVCCStrategy {
      */
     exists(pageId: number): Promise<boolean>;
     /**
-     * 현재 파일 크기 반환
+     * 메인 DB 파일의 물리적 동기화를 수행합니다 (fsync).
      */
-    getFileSize(): number;
+    sync(): Promise<void>;
     /**
-     * 캐시 초기화
+     * 현재 파일 크기 반환
      */
-    clearCache(): void;
+    getFileSize(): number;
     private _readFromDisk;
     private _writeToDisk;
 }

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

@@ -1,10 +1,12 @@
 import type { PageFileSystem } from '../PageFileSystem';
+import type { AsyncMVCCTransaction } from 'mvcc-api';
+import type { PageMVCCStrategy } from '../PageMVCCStrategy';
 import { LockManager } from './LockManager';
 import { TransactionContext } from './TxContext';
-import { PageMVCCStrategy } from '../PageMVCCStrategy';
 /**
  * Transaction class.
  * Manages the lifecycle and resources of a database transaction.
+ * Internally wraps a nested AsyncMVCCTransaction for snapshot isolation.
  */
 export declare class Transaction {
     readonly context: TransactionContext;
@@ -16,25 +18,28 @@ export declare class Transaction {
     private heldLocks;
     /** Held page locks (PageID -> LockID) */
     private pageLocks;
-    /** Dirty Pages modified by the transaction: PageID -> Modified Page Buffer */
-    private dirtyPages;
-    /** Undo pages: PageID -> Original Page Buffer (Snapshot) */
-    private undoPages;
     /** List of callbacks to execute on commit */
     private commitHooks;
-    /** Page MVCC Strategy for disk access */
-    private readonly pageStrategy;
+    /** Nested MVCC Transaction for snapshot isolation (lazy init) */
+    private mvccTx;
+    /** Root MVCC Transaction reference */
+    private readonly rootTx;
     /** Release function for global write lock, set by DataplyAPI */
     private _writeLockRelease;
     /**
      * @param id Transaction ID
      * @param context Transaction context
-     * @param pageStrategy Page MVCC Strategy for disk I/O
+     * @param rootTx Root MVCC Transaction
      * @param lockManager LockManager instance
      * @param pfs Page File System
-     * @param reloadBPTree Callback to reload BPTree cache on rollback
      */
-    constructor(id: number, context: TransactionContext, pageStrategy: PageMVCCStrategy, lockManager: LockManager, pfs: PageFileSystem);
+    constructor(id: number, context: TransactionContext, rootTx: AsyncMVCCTransaction<PageMVCCStrategy, number, Uint8Array>, lockManager: LockManager, pfs: PageFileSystem);
+    /**
+     * Lazily initializes the nested MVCC transaction.
+     * This ensures the snapshot is taken at the time of first access,
+     * picking up the latest committed root version.
+     */
+    private ensureMvccTx;
     /**
      * Registers a commit hook.
      * @param hook Function to execute
@@ -50,13 +55,13 @@ export declare class Transaction {
      */
     __hasWriteLockRelease(): boolean;
     /**
-     * Reads a page. Uses dirty buffer if available, otherwise disk.
+     * Reads a page through the MVCC transaction.
      * @param pageId Page ID
      * @returns Page data
      */
     readPage(pageId: number): Promise<Uint8Array>;
     /**
-     * Writes a page to the transaction buffer.
+     * Writes a page through the MVCC transaction.
      * @param pageId Page ID
      * @param data Page data
      */
@@ -74,10 +79,6 @@ export declare class Transaction {
      * Rolls back the transaction.
      */
     rollback(): Promise<void>;
-    /**
-     * Returns the dirty pages map.
-     */
-    __getDirtyPages(): Map<number, Uint8Array>;
     /**
      * Releases all locks.
      */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dataply",
-  "version": "0.0.26-alpha.5",
+  "version": "0.0.26-alpha.6",
   "description": "A lightweight storage engine for Node.js with support for MVCC, WAL.",
   "license": "MIT",
   "author": "izure <admin@izure.org>",