mvcc-api 1.0.3 → 1.2.0

package/dist/cjs/index.cjs

@@ -20,251 +20,374 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
-  AsyncMVCCManager: () => AsyncMVCCManager,
   AsyncMVCCStrategy: () => AsyncMVCCStrategy,
   AsyncMVCCTransaction: () => AsyncMVCCTransaction,
-  SyncMVCCManager: () => SyncMVCCManager,
   SyncMVCCStrategy: () => SyncMVCCStrategy,
   SyncMVCCTransaction: () => SyncMVCCTransaction
 });
 module.exports = __toCommonJS(src_exports);
 
-// src/core/base/Manager.ts
-var MVCCManager = class {
-  version;
-  strategy;
-  versionIndex;
-  activeTransactions;
-  deletedCache;
-  constructor(strategy) {
-    this.strategy = strategy;
-    this.version = 0;
-    this.activeTransactions = /* @__PURE__ */ new Set();
-    this.deletedCache = /* @__PURE__ */ new Map();
-    this.versionIndex = /* @__PURE__ */ new Map();
-  }
-  _removeTransaction(tx) {
-    this.activeTransactions.delete(tx);
-    this._cleanupDeletedCache();
-  }
-  _cleanupDeletedCache() {
-    let minVersion = this.version;
-    for (const tx of this.activeTransactions) {
-      minVersion = Math.min(minVersion, tx.snapshotVersion);
-    }
-    for (const [key, versions] of this.versionIndex.entries()) {
-      const toKeep = [];
-      let keptOldVersion = false;
-      let i = versions.length;
-      while (i--) {
-        const v = versions[i];
-        if (v.version > minVersion) {
-          toKeep.unshift(v);
-        } else if (!keptOldVersion) {
-          toKeep.unshift(v);
-          keptOldVersion = true;
-        }
-      }
-      if (toKeep.length === 0) {
-        this.versionIndex.delete(key);
-      } else {
-        this.versionIndex.set(key, toKeep);
-      }
-    }
-    for (const [key, versions] of this.deletedCache.entries()) {
-      const filtered = versions.filter((v) => v.deletedAtVersion >= minVersion);
-      if (filtered.length === 0) {
-        this.deletedCache.delete(key);
-      } else {
-        this.deletedCache.set(key, filtered);
-      }
-    }
-  }
-};
-
 // src/core/base/Strategy.ts
 var MVCCStrategy = class {
 };
 
 // src/core/base/Transaction.ts
 var MVCCTransaction = class {
-  manager;
   committed;
   snapshotVersion;
+  snapshotLocalVersion;
   writeBuffer;
   deleteBuffer;
-  constructor(manager, snapshotVersion) {
-    this.manager = manager;
-    this.snapshotVersion = snapshotVersion;
+  createdKeys;
+  // create()로 생성된 키 추적
+  deletedValues;
+  // delete 시 삭제 전 값 저장
+  // Nested Transaction Properties
+  parent;
+  localVersion;
+  // Local version for Nested Conflict Detection
+  keyVersions;
+  // Key -> Local Version (When it was modified locally)
+  // Root Transaction Properties (Only populated if this is Root)
+  root;
+  strategy;
+  version = 0;
+  versionIndex = /* @__PURE__ */ new Map();
+  deletedCache = /* @__PURE__ */ new Map();
+  activeTransactions = /* @__PURE__ */ new Set();
+  constructor(strategy, parent, snapshotVersion) {
+    this.snapshotVersion = snapshotVersion ?? 0;
     this.writeBuffer = /* @__PURE__ */ new Map();
     this.deleteBuffer = /* @__PURE__ */ new Set();
+    this.createdKeys = /* @__PURE__ */ new Set();
+    this.deletedValues = /* @__PURE__ */ new Map();
     this.committed = false;
-  }
-  /**
-   * Schedules a creation (insert) of a key-value pair.
-   * Throws if the transaction is already committed.
-   * @param key The key to create.
-   * @param value The value to store.
-   * @returns The transaction instance for chaining.
-   */
-  create(key, value) {
-    if (this.committed) throw new Error("Transaction already committed");
+    this.parent = parent;
+    this.keyVersions = /* @__PURE__ */ new Map();
+    if (parent) {
+      this.localVersion = parent.localVersion;
+      this.snapshotLocalVersion = parent.localVersion;
+      this.strategy = void 0;
+      this.root = parent.root;
+    } else {
+      if (!strategy) throw new Error("Root Transaction must get Strategy");
+      this.strategy = strategy;
+      this.version = 0;
+      this.localVersion = 0;
+      this.snapshotLocalVersion = 0;
+      this.root = this;
+    }
+  }
+  isRoot() {
+    return !this.parent;
+  }
+  // --- Internal buffer manipulation helpers ---
+  _bufferCreate(key, value) {
+    this.localVersion++;
     this.writeBuffer.set(key, value);
-    return this;
+    this.createdKeys.add(key);
+    this.deleteBuffer.delete(key);
+    this.keyVersions.set(key, this.localVersion);
   }
-  /**
-   * Schedules a write (update) of a key-value pair.
-   * Overwrites any existing value in the buffer.
-   * @param key The key to write.
-   * @param value The value to store.
-   * @returns The transaction instance for chaining.
-   */
-  write(key, value) {
-    if (this.committed) throw new Error("Transaction already committed");
+  _bufferWrite(key, value) {
+    this.localVersion++;
     this.writeBuffer.set(key, value);
     this.deleteBuffer.delete(key);
-    return this;
+    this.keyVersions.set(key, this.localVersion);
   }
-  /**
-   * Schedules a deletion of a key.
-   * @param key The key to delete.
-   * @returns The transaction instance for chaining.
-   */
-  delete(key) {
-    if (this.committed) throw new Error("Transaction already committed");
+  _bufferDelete(key) {
+    this.localVersion++;
     this.deleteBuffer.add(key);
     this.writeBuffer.delete(key);
-    return this;
+    this.createdKeys.delete(key);
+    this.keyVersions.set(key, this.localVersion);
   }
   /**
    * Rolls back the transaction.
    * Clears all buffers and marks the transaction as finished.
-   * @returns The transaction instance.
+   * @returns The result object with success, created, updated, and deleted keys.
    */
   rollback() {
+    const created = [];
+    const updated = [];
+    for (const [key, data] of this.writeBuffer.entries()) {
+      if (this.createdKeys.has(key)) {
+        created.push({ key, data });
+      } else {
+        updated.push({ key, data });
+      }
+    }
+    const deleted = [];
+    for (const key of this.deleteBuffer) {
+      const data = this.deletedValues.get(key);
+      if (data !== void 0) {
+        deleted.push({ key, data });
+      }
+    }
     this.writeBuffer.clear();
     this.deleteBuffer.clear();
+    this.createdKeys.clear();
+    this.deletedValues.clear();
     this.committed = true;
-    this.manager._removeTransaction(this);
-    return this;
+    if (this.root !== this) {
+      this.root.activeTransactions.delete(this);
+    }
+    return { success: true, created, updated, deleted };
   }
 };
 
+// src/core/sync/Strategy.ts
+var SyncMVCCStrategy = class extends MVCCStrategy {
+};
+
 // src/core/sync/Transaction.ts
-var SyncMVCCTransaction = class extends MVCCTransaction {
-  read(key) {
+var SyncMVCCTransaction = class _SyncMVCCTransaction extends MVCCTransaction {
+  create(key, value) {
     if (this.committed) throw new Error("Transaction already committed");
-    if (this.writeBuffer.has(key)) {
-      return this.writeBuffer.get(key);
+    if (this.writeBuffer.has(key) || !this.deleteBuffer.has(key) && this.read(key) !== null) {
+      throw new Error(`Key already exists: ${key}`);
     }
-    if (this.deleteBuffer.has(key)) {
-      return null;
+    this._bufferCreate(key, value);
+    return this;
+  }
+  write(key, value) {
+    if (this.committed) throw new Error("Transaction already committed");
+    if (!this.writeBuffer.has(key) && (this.deleteBuffer.has(key) || this.read(key) === null)) {
+      throw new Error(`Key not found: ${key}`);
     }
-    return this.manager._diskRead(key, this.snapshotVersion);
+    this._bufferWrite(key, value);
+    return this;
   }
-  commit() {
+  delete(key) {
     if (this.committed) throw new Error("Transaction already committed");
-    this.manager._commit(this);
-    this.committed = true;
-    this.manager._removeTransaction(this);
+    let valueToDelete = null;
+    if (this.writeBuffer.has(key)) {
+      valueToDelete = this.writeBuffer.get(key);
+    } else if (!this.deleteBuffer.has(key)) {
+      valueToDelete = this.read(key);
+    }
+    if (valueToDelete === null) {
+      throw new Error(`Key not found: ${key}`);
+    }
+    this.deletedValues.set(key, valueToDelete);
+    this._bufferDelete(key);
     return this;
   }
-};
-
-// src/core/sync/Manager.ts
-var SyncMVCCManager = class extends MVCCManager {
-  constructor(strategy) {
-    super(strategy);
+  createNested() {
+    if (this.committed) throw new Error("Transaction already committed");
+    const childVersion = this.isRoot() ? this.version : this.snapshotVersion;
+    const child = new _SyncMVCCTransaction(void 0, this, childVersion);
+    this.root.activeTransactions.add(child);
+    return child;
   }
-  createTransaction() {
-    const tx = new SyncMVCCTransaction(this, this.version);
-    this.activeTransactions.add(tx);
-    return tx;
+  read(key) {
+    if (this.committed) throw new Error("Transaction already committed");
+    if (this.writeBuffer.has(key)) return this.writeBuffer.get(key);
+    if (this.deleteBuffer.has(key)) return null;
+    return this.root._diskRead(key, this.snapshotVersion);
   }
-  _diskWrite(key, value, version) {
-    if (this.strategy.exists(key)) {
-      const oldValue = this.strategy.read(key);
-      if (!this.deletedCache.has(key)) {
-        this.deletedCache.set(key, []);
+  _readSnapshot(key, snapshotVersion, snapshotLocalVersion) {
+    if (this.writeBuffer.has(key)) {
+      const keyModVersion = this.keyVersions.get(key);
+      if (snapshotLocalVersion === void 0 || keyModVersion === void 0 || keyModVersion <= snapshotLocalVersion) {
+        return this.writeBuffer.get(key);
       }
-      this.deletedCache.get(key).push({ value: oldValue, deletedAtVersion: version });
     }
-    this.strategy.write(key, value);
-    if (!this.versionIndex.has(key)) {
-      this.versionIndex.set(key, []);
+    if (this.deleteBuffer.has(key)) {
+      const keyModVersion = this.keyVersions.get(key);
+      if (snapshotLocalVersion === void 0 || keyModVersion === void 0 || keyModVersion <= snapshotLocalVersion) {
+        return null;
+      }
+    }
+    if (this.parent) {
+      return this.parent._readSnapshot(key, snapshotVersion, this.snapshotLocalVersion);
+    } else {
+      return this._diskRead(key, snapshotVersion);
     }
-    this.versionIndex.get(key).push({ version, exists: true });
   }
-  _diskRead(key, snapshotVersion) {
-    if (!this.versionIndex.has(key) && !this.deletedCache.has(key)) {
-      if (this.strategy.exists(key)) {
-        return this.strategy.read(key);
+  commit() {
+    if (this.committed) {
+      return { success: false, error: "Transaction already committed", created: [], updated: [], deleted: [] };
+    }
+    const created = [];
+    const updated = [];
+    for (const [key, data] of this.writeBuffer.entries()) {
+      if (this.createdKeys.has(key)) {
+        created.push({ key, data });
+      } else {
+        updated.push({ key, data });
       }
-      return null;
     }
-    const versions = this.versionIndex.get(key);
-    if (versions && versions.length > 0) {
-      const visibleVersions = versions.filter((v) => v.version <= snapshotVersion && v.exists);
-      if (visibleVersions.length > 0) {
-        const newerVersions = versions.filter((v) => v.version > snapshotVersion);
-        if (newerVersions.length === 0) {
-          return this.strategy.read(key);
+    const deleted = [];
+    for (const key of this.deleteBuffer) {
+      const data = this.deletedValues.get(key);
+      if (data !== void 0) {
+        deleted.push({ key, data });
+      }
+    }
+    if (this.parent) {
+      const error = this.parent._merge(this);
+      if (error) {
+        return { success: false, error, created: [], updated: [], deleted: [] };
+      }
+      this.committed = true;
+    } else {
+      if (this.writeBuffer.size > 0 || this.deleteBuffer.size > 0) {
+        const error = this._merge(this);
+        if (error) {
+          return { success: false, error, created: [], updated: [], deleted: [] };
         }
+        this.writeBuffer.clear();
+        this.deleteBuffer.clear();
+        this.createdKeys.clear();
+        this.deletedValues.clear();
+        this.keyVersions.clear();
+        this.localVersion = 0;
       }
     }
-    const cached = this.deletedCache.get(key);
-    if (cached) {
-      const visibleEntries = cached.filter((v) => v.deletedAtVersion > snapshotVersion);
-      if (visibleEntries.length > 0) {
-        visibleEntries.sort((a, b) => a.deletedAtVersion - b.deletedAtVersion);
-        return visibleEntries[0].value;
+    return { success: true, created, updated, deleted };
+  }
+  _merge(child) {
+    if (this.parent) {
+      for (const key of child.writeBuffer.keys()) {
+        const lastModLocalVer = this.keyVersions.get(key);
+        if (lastModLocalVer !== void 0 && lastModLocalVer > child.snapshotLocalVersion) {
+          return `Commit conflict: Key '${key}' was modified by a newer transaction (Local v${lastModLocalVer})`;
+        }
+      }
+      for (const key of child.deleteBuffer) {
+        const lastModLocalVer = this.keyVersions.get(key);
+        if (lastModLocalVer !== void 0 && lastModLocalVer > child.snapshotLocalVersion) {
+          return `Commit conflict: Key '${key}' was modified by a newer transaction (Local v${lastModLocalVer})`;
+        }
+      }
+      const newLocalVersion = this.localVersion + 1;
+      for (const key of child.writeBuffer.keys()) {
+        this.writeBuffer.set(key, child.writeBuffer.get(key));
+        this.deleteBuffer.delete(key);
+        this.keyVersions.set(key, newLocalVersion);
+        if (child.createdKeys.has(key)) {
+          this.createdKeys.add(key);
+        }
+      }
+      for (const key of child.deleteBuffer) {
+        this.deleteBuffer.add(key);
+        this.writeBuffer.delete(key);
+        this.createdKeys.delete(key);
+        this.keyVersions.set(key, newLocalVersion);
+        const deletedValue = child.deletedValues.get(key);
+        if (deletedValue !== void 0) {
+          this.deletedValues.set(key, deletedValue);
+        }
+      }
+      this.localVersion = newLocalVersion;
+      this.root.activeTransactions.delete(child);
+    } else {
+      this.root.activeTransactions.delete(child);
+      const newVersion = this.version + 1;
+      const modifiedKeys = /* @__PURE__ */ new Set([...child.writeBuffer.keys(), ...child.deleteBuffer]);
+      for (const key of modifiedKeys) {
+        const versions = this.versionIndex.get(key);
+        if (versions && versions.length > 0) {
+          const lastVer = versions[versions.length - 1].version;
+          if (lastVer > child.snapshotVersion) {
+            return `Commit conflict: Key '${key}' was modified by a newer transaction (v${lastVer})`;
+          }
+        }
       }
+      for (const [key, value] of child.writeBuffer) {
+        this._diskWrite(key, value, newVersion);
+      }
+      for (const key of child.deleteBuffer) {
+        this._diskDelete(key, newVersion);
+      }
+      this.version = newVersion;
+      this._cleanupDeletedCache();
     }
     return null;
   }
-  _diskDelete(key, snapshotVersion) {
-    if (this.strategy.exists(key)) {
-      const data = this.strategy.read(key);
-      if (!this.deletedCache.has(key)) {
-        this.deletedCache.set(key, []);
+  // --- Internal IO Helpers (Root Only) ---
+  _diskWrite(key, value, version) {
+    const strategy = this.strategy;
+    if (!strategy) throw new Error("Root Transaction missing strategy");
+    if (strategy.exists(key)) {
+      const currentVal = strategy.read(key);
+      if (!this.deletedCache.has(key)) this.deletedCache.set(key, []);
+      this.deletedCache.get(key).push({
+        value: currentVal,
+        deletedAtVersion: version
+      });
+    }
+    strategy.write(key, value);
+    if (!this.versionIndex.has(key)) this.versionIndex.set(key, []);
+    this.versionIndex.get(key).push({ version, exists: true });
+  }
+  _diskRead(key, snapshotVersion) {
+    const strategy = this.strategy;
+    if (!strategy) throw new Error("Root Transaction missing strategy");
+    const versions = this.versionIndex.get(key);
+    if (!versions) {
+      return strategy.exists(key) ? strategy.read(key) : null;
+    }
+    let targetVerObj = null;
+    let nextVerObj = null;
+    for (const v of versions) {
+      if (v.version <= snapshotVersion) {
+        targetVerObj = v;
+      } else {
+        nextVerObj = v;
+        break;
       }
-      this.deletedCache.get(key).push({ deletedAtVersion: snapshotVersion, value: data });
-      this.strategy.delete(key);
     }
-    if (!this.versionIndex.has(key)) {
-      this.versionIndex.set(key, []);
+    if (!targetVerObj || !targetVerObj.exists) return null;
+    if (!nextVerObj) {
+      return strategy.read(key);
+    }
+    const cached = this.deletedCache.get(key);
+    if (cached) {
+      const match = cached.find((c) => c.deletedAtVersion === nextVerObj.version);
+      if (match) return match.value;
     }
+    return null;
+  }
+  _diskDelete(key, snapshotVersion) {
+    const strategy = this.strategy;
+    if (!strategy) throw new Error("Root Transaction missing strategy");
+    if (strategy.exists(key)) {
+      const currentVal = strategy.read(key);
+      if (!this.deletedCache.has(key)) this.deletedCache.set(key, []);
+      this.deletedCache.get(key).push({
+        value: currentVal,
+        deletedAtVersion: snapshotVersion
+      });
+    }
+    strategy.delete(key);
+    if (!this.versionIndex.has(key)) this.versionIndex.set(key, []);
     this.versionIndex.get(key).push({ version: snapshotVersion, exists: false });
   }
-  _commit(tx) {
-    const isReadOnly = tx.writeBuffer.size === 0 && tx.deleteBuffer.size === 0;
-    if (!isReadOnly && this.version > tx.snapshotVersion) {
-      const affectedKeys = /* @__PURE__ */ new Set([
-        ...tx.writeBuffer.keys(),
-        ...tx.deleteBuffer
-      ]);
-      for (const key of affectedKeys) {
-        const versions = this.versionIndex.get(key);
-        if (versions && versions.length > 0) {
-          const latestVersion = versions[versions.length - 1].version;
-          if (latestVersion > tx.snapshotVersion) {
-            throw new Error(`Commit conflict: file '${key}' was modified by another transaction`);
-          }
+  _cleanupDeletedCache() {
+    if (this.deletedCache.size === 0) return;
+    let minActiveVersion = this.version;
+    if (this.activeTransactions.size > 0) {
+      for (const tx of this.activeTransactions) {
+        if (!tx.committed && tx.snapshotVersion < minActiveVersion) {
+          minActiveVersion = tx.snapshotVersion;
         }
       }
     }
-    this.version++;
-    for (const key of tx.deleteBuffer) {
-      this._diskDelete(key, this.version);
-    }
-    for (const [key, value] of tx.writeBuffer) {
-      this._diskWrite(key, value, this.version);
+    for (const [key, cachedList] of this.deletedCache) {
+      const remaining = cachedList.filter((item) => item.deletedAtVersion > minActiveVersion);
+      if (remaining.length === 0) {
+        this.deletedCache.delete(key);
+      } else {
+        this.deletedCache.set(key, remaining);
+      }
     }
   }
 };
 
-// src/core/sync/Strategy.ts
-var SyncMVCCStrategy = class extends MVCCStrategy {
+// src/core/async/Strategy.ts
+var AsyncMVCCStrategy = class extends MVCCStrategy {
 };
 
 // node_modules/ryoiki/dist/esm/index.mjs
@@ -526,140 +649,261 @@ var Ryoiki = class _Ryoiki {
 };
 
 // src/core/async/Transaction.ts
-var AsyncMVCCTransaction = class extends MVCCTransaction {
+var AsyncMVCCTransaction = class _AsyncMVCCTransaction extends MVCCTransaction {
+  lock = new Ryoiki();
+  async writeLock(fn) {
+    let lockId;
+    return this.lock.writeLock(async (_lockId) => {
+      lockId = _lockId;
+      return fn();
+    }).finally(() => {
+      this.lock.writeUnlock(lockId);
+    });
+  }
+  async create(key, value) {
+    if (this.committed) throw new Error("Transaction already committed");
+    if (this.writeBuffer.has(key) || !this.deleteBuffer.has(key) && await this.read(key) !== null) {
+      throw new Error(`Key already exists: ${key}`);
+    }
+    this._bufferCreate(key, value);
+    return this;
+  }
+  async write(key, value) {
+    if (this.committed) throw new Error("Transaction already committed");
+    if (!this.writeBuffer.has(key) && (this.deleteBuffer.has(key) || await this.read(key) === null)) {
+      throw new Error(`Key not found: ${key}`);
+    }
+    this._bufferWrite(key, value);
+    return this;
+  }
+  async delete(key) {
+    if (this.committed) throw new Error("Transaction already committed");
+    let valueToDelete = null;
+    if (this.writeBuffer.has(key)) {
+      valueToDelete = this.writeBuffer.get(key);
+    } else if (!this.deleteBuffer.has(key)) {
+      valueToDelete = await this.read(key);
+    }
+    if (valueToDelete === null) {
+      throw new Error(`Key not found: ${key}`);
+    }
+    this.deletedValues.set(key, valueToDelete);
+    this._bufferDelete(key);
+    return this;
+  }
+  createNested() {
+    if (this.committed) throw new Error("Transaction already committed");
+    const childVersion = this.isRoot() ? this.version : this.snapshotVersion;
+    const child = new _AsyncMVCCTransaction(void 0, this, childVersion);
+    this.root.activeTransactions.add(child);
+    return child;
+  }
   async read(key) {
     if (this.committed) throw new Error("Transaction already committed");
+    if (this.writeBuffer.has(key)) return this.writeBuffer.get(key);
+    if (this.deleteBuffer.has(key)) return null;
+    return this.root._diskRead(key, this.snapshotVersion);
+  }
+  async _readSnapshot(key, snapshotVersion, snapshotLocalVersion) {
     if (this.writeBuffer.has(key)) {
-      return this.writeBuffer.get(key);
+      const keyModVersion = this.keyVersions.get(key);
+      if (snapshotLocalVersion === void 0 || keyModVersion === void 0 || keyModVersion <= snapshotLocalVersion) {
+        return this.writeBuffer.get(key);
+      }
     }
     if (this.deleteBuffer.has(key)) {
-      return null;
+      const keyModVersion = this.keyVersions.get(key);
+      if (snapshotLocalVersion === void 0 || keyModVersion === void 0 || keyModVersion <= snapshotLocalVersion) {
+        return null;
+      }
+    }
+    if (this.parent) {
+      return this.parent._readSnapshot(key, snapshotVersion, this.snapshotLocalVersion);
+    } else {
+      return this._diskRead(key, snapshotVersion);
     }
-    return this.manager._diskRead(key, this.snapshotVersion);
   }
   async commit() {
-    return this.manager.writeLock(async () => {
-      if (this.committed) throw new Error("Transaction already committed");
-      await this.manager._commit(this);
-      this.committed = true;
-      this.manager._removeTransaction(this);
-      return this;
+    return this.writeLock(async () => {
+      if (this.committed) {
+        return { success: false, error: "Transaction already committed", created: [], updated: [], deleted: [] };
+      }
+      const created = [];
+      const updated = [];
+      for (const [key, data] of this.writeBuffer.entries()) {
+        if (this.createdKeys.has(key)) {
+          created.push({ key, data });
+        } else {
+          updated.push({ key, data });
+        }
+      }
+      const deleted = [];
+      for (const key of this.deleteBuffer) {
+        const data = this.deletedValues.get(key);
+        if (data !== void 0) {
+          deleted.push({ key, data });
+        }
+      }
+      if (this.parent) {
+        const error = await this.parent._merge(this);
+        if (error) {
+          return { success: false, error, created: [], updated: [], deleted: [] };
+        }
+        this.committed = true;
+      } else {
+        if (this.writeBuffer.size > 0 || this.deleteBuffer.size > 0) {
+          const error = await this._merge(this);
+          if (error) {
+            return { success: false, error, created: [], updated: [], deleted: [] };
+          }
+          this.writeBuffer.clear();
+          this.deleteBuffer.clear();
+          this.createdKeys.clear();
+          this.deletedValues.clear();
+          this.keyVersions.clear();
+          this.localVersion = 0;
+        }
+      }
+      return { success: true, created, updated, deleted };
     });
   }
-};
-
-// src/core/async/Manager.ts
-var AsyncMVCCManager = class extends MVCCManager {
-  lock;
-  constructor(strategy) {
-    super(strategy);
-    this.lock = new Ryoiki();
-  }
-  createTransaction() {
-    const tx = new AsyncMVCCTransaction(this, this.version);
-    this.activeTransactions.add(tx);
-    return tx;
-  }
-  async writeLock(fn) {
-    let lockId;
-    return this.lock.writeLock(async (_lockId) => {
-      lockId = _lockId;
-      return fn();
-    }).finally(() => {
-      this.lock.writeUnlock(lockId);
+  async _merge(child) {
+    return this.writeLock(async () => {
+      if (this.parent) {
+        for (const key of child.writeBuffer.keys()) {
+          const lastModLocalVer = this.keyVersions.get(key);
+          if (lastModLocalVer !== void 0 && lastModLocalVer > child.snapshotLocalVersion) {
+            return `Commit conflict: Key '${key}' was modified by a newer transaction (Local v${lastModLocalVer})`;
+          }
+        }
+        for (const key of child.deleteBuffer) {
+          const lastModLocalVer = this.keyVersions.get(key);
+          if (lastModLocalVer !== void 0 && lastModLocalVer > child.snapshotLocalVersion) {
+            return `Commit conflict: Key '${key}' was modified by a newer transaction (Local v${lastModLocalVer})`;
+          }
+        }
+        const newLocalVersion = this.localVersion + 1;
+        for (const key of child.writeBuffer.keys()) {
+          this.writeBuffer.set(key, child.writeBuffer.get(key));
+          this.deleteBuffer.delete(key);
+          this.keyVersions.set(key, newLocalVersion);
+          if (child.createdKeys.has(key)) {
+            this.createdKeys.add(key);
+          }
+        }
+        for (const key of child.deleteBuffer) {
+          this.deleteBuffer.add(key);
+          this.writeBuffer.delete(key);
+          this.createdKeys.delete(key);
+          this.keyVersions.set(key, newLocalVersion);
+          const deletedValue = child.deletedValues.get(key);
+          if (deletedValue !== void 0) {
+            this.deletedValues.set(key, deletedValue);
+          }
+        }
+        this.localVersion = newLocalVersion;
+        this.root.activeTransactions.delete(child);
+      } else {
+        this.root.activeTransactions.delete(child);
+        const newVersion = this.version + 1;
+        const modifiedKeys = /* @__PURE__ */ new Set([...child.writeBuffer.keys(), ...child.deleteBuffer]);
+        for (const key of modifiedKeys) {
+          const versions = this.versionIndex.get(key);
+          if (versions && versions.length > 0) {
+            const lastVer = versions[versions.length - 1].version;
+            if (lastVer > child.snapshotVersion) {
+              return `Commit conflict: Key '${key}' was modified by a newer transaction (v${lastVer})`;
+            }
+          }
+        }
+        for (const [key, value] of child.writeBuffer) {
+          await this._diskWrite(key, value, newVersion);
+        }
+        for (const key of child.deleteBuffer) {
+          await this._diskDelete(key, newVersion);
+        }
+        this.version = newVersion;
+        this._cleanupDeletedCache();
+      }
+      return null;
     });
   }
+  // --- Internal IO Helpers (Root Only) ---
   async _diskWrite(key, value, version) {
-    if (await this.strategy.exists(key)) {
-      const oldValue = await this.strategy.read(key);
-      if (!this.deletedCache.has(key)) {
-        this.deletedCache.set(key, []);
-      }
-      this.deletedCache.get(key).push({ value: oldValue, deletedAtVersion: version });
-    }
-    await this.strategy.write(key, value);
-    if (!this.versionIndex.has(key)) {
-      this.versionIndex.set(key, []);
-    }
+    const strategy = this.strategy;
+    if (!strategy) throw new Error("Root Transaction missing strategy");
+    if (await strategy.exists(key)) {
+      const currentVal = await strategy.read(key);
+      if (!this.deletedCache.has(key)) this.deletedCache.set(key, []);
+      this.deletedCache.get(key).push({
+        value: currentVal,
+        deletedAtVersion: version
+      });
+    }
+    await strategy.write(key, value);
+    if (!this.versionIndex.has(key)) this.versionIndex.set(key, []);
     this.versionIndex.get(key).push({ version, exists: true });
   }
   async _diskRead(key, snapshotVersion) {
-    if (!this.versionIndex.has(key) && !this.deletedCache.has(key)) {
-      if (await this.strategy.exists(key)) {
-        return this.strategy.read(key);
-      }
-      return null;
-    }
+    const strategy = this.strategy;
+    if (!strategy) throw new Error("Root Transaction missing strategy");
     const versions = this.versionIndex.get(key);
-    if (versions && versions.length > 0) {
-      const visibleVersions = versions.filter((v) => v.version <= snapshotVersion && v.exists);
-      if (visibleVersions.length > 0) {
-        const newerVersions = versions.filter((v) => v.version > snapshotVersion);
-        if (newerVersions.length === 0) {
-          return this.strategy.read(key);
-        }
+    if (!versions) {
+      return await strategy.exists(key) ? strategy.read(key) : null;
+    }
+    let targetVerObj = null;
+    let nextVerObj = null;
+    for (const v of versions) {
+      if (v.version <= snapshotVersion) {
+        targetVerObj = v;
+      } else {
+        nextVerObj = v;
+        break;
       }
     }
+    if (!targetVerObj || !targetVerObj.exists) return null;
+    if (!nextVerObj) {
+      return strategy.read(key);
+    }
     const cached = this.deletedCache.get(key);
     if (cached) {
-      const visibleEntries = cached.filter((v) => v.deletedAtVersion > snapshotVersion);
-      if (visibleEntries.length > 0) {
-        visibleEntries.sort((a, b) => a.deletedAtVersion - b.deletedAtVersion);
-        return visibleEntries[0].value;
-      }
+      const match = cached.find((c) => c.deletedAtVersion === nextVerObj.version);
+      if (match) return match.value;
     }
     return null;
   }
   async _diskDelete(key, snapshotVersion) {
-    if (await this.strategy.exists(key)) {
-      const data = await this.strategy.read(key);
-      if (!this.deletedCache.has(key)) {
-        this.deletedCache.set(key, []);
-      }
-      this.deletedCache.get(key).push({ deletedAtVersion: snapshotVersion, value: data });
-      await this.strategy.delete(key);
-    }
-    if (!this.versionIndex.has(key)) {
-      this.versionIndex.set(key, []);
-    }
+    const strategy = this.strategy;
+    if (!strategy) throw new Error("Root Transaction missing strategy");
+    if (await strategy.exists(key)) {
+      const currentVal = await strategy.read(key);
+      if (!this.deletedCache.has(key)) this.deletedCache.set(key, []);
+      this.deletedCache.get(key).push({
+        value: currentVal,
+        deletedAtVersion: snapshotVersion
+      });
+    }
+    await strategy.delete(key);
+    if (!this.versionIndex.has(key)) this.versionIndex.set(key, []);
     this.versionIndex.get(key).push({ version: snapshotVersion, exists: false });
   }
-  async _commit(tx) {
-    const isReadOnly = tx.writeBuffer.size === 0 && tx.deleteBuffer.size === 0;
-    if (!isReadOnly && this.version > tx.snapshotVersion) {
-      const affectedKeys = /* @__PURE__ */ new Set([
-        ...tx.writeBuffer.keys(),
-        ...tx.deleteBuffer
-      ]);
-      for (const key of affectedKeys) {
-        const versions = this.versionIndex.get(key);
-        if (versions && versions.length > 0) {
-          const latestVersion = versions[versions.length - 1].version;
-          if (latestVersion > tx.snapshotVersion) {
-            throw new Error(`Commit conflict: file '${key}' was modified by another transaction`);
-          }
+  _cleanupDeletedCache() {
+    if (this.deletedCache.size === 0) return;
+    let minActiveVersion = this.version;
+    if (this.activeTransactions.size > 0) {
+      for (const tx of this.activeTransactions) {
+        if (!tx.committed && tx.snapshotVersion < minActiveVersion) {
+          minActiveVersion = tx.snapshotVersion;
         }
       }
     }
-    this.version++;
-    for (const key of tx.deleteBuffer) {
-      await this._diskDelete(key, this.version);
-    }
-    for (const [key, value] of tx.writeBuffer) {
-      await this._diskWrite(key, value, this.version);
+    for (const [key, cachedList] of this.deletedCache) {
+      const remaining = cachedList.filter((item) => item.deletedAtVersion > minActiveVersion);
+      if (remaining.length === 0) {
+        this.deletedCache.delete(key);
+      } else {
+        this.deletedCache.set(key, remaining);
+      }
     }
   }
 };
-
-// src/core/async/Strategy.ts
-var AsyncMVCCStrategy = class extends MVCCStrategy {
-};
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  AsyncMVCCManager,
-  AsyncMVCCStrategy,
-  AsyncMVCCTransaction,
-  SyncMVCCManager,
-  SyncMVCCStrategy,
-  SyncMVCCTransaction
-});