mvcc-api 1.0.3 → 1.1.0

package/dist/esm/index.mjs

@@ -1,73 +1,50 @@
-// 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;
+  // 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.committed = false;
+    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;
   }
   /**
    * Schedules a creation (insert) of a key-value pair.
@@ -90,8 +67,10 @@ var MVCCTransaction = class {
    */
   write(key, value) {
     if (this.committed) throw new Error("Transaction already committed");
+    this.localVersion++;
     this.writeBuffer.set(key, value);
     this.deleteBuffer.delete(key);
+    this.keyVersions.set(key, this.localVersion);
     return this;
   }
   /**
@@ -101,8 +80,10 @@ var MVCCTransaction = class {
    */
   delete(key) {
     if (this.committed) throw new Error("Transaction already committed");
+    this.localVersion++;
     this.deleteBuffer.add(key);
     this.writeBuffer.delete(key);
+    this.keyVersions.set(key, this.localVersion);
     return this;
   }
   /**
@@ -114,126 +95,196 @@ var MVCCTransaction = class {
     this.writeBuffer.clear();
     this.deleteBuffer.clear();
     this.committed = true;
-    this.manager._removeTransaction(this);
+    if (this.root !== this) {
+      this.root.activeTransactions.delete(this);
+    }
     return this;
   }
 };
 
+// src/core/sync/Strategy.ts
+var SyncMVCCStrategy = class extends MVCCStrategy {
+};
+
 // src/core/sync/Transaction.ts
-var SyncMVCCTransaction = class extends MVCCTransaction {
+var SyncMVCCTransaction = class _SyncMVCCTransaction extends MVCCTransaction {
+  createNested() {
+    const childVersion = this.isRoot() ? this.version : this.snapshotVersion;
+    const child = new _SyncMVCCTransaction(void 0, this, childVersion);
+    this.root.activeTransactions.add(child);
+    return child;
+  }
   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);
+  }
+  _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);
   }
   commit() {
     if (this.committed) throw new Error("Transaction already committed");
-    this.manager._commit(this);
-    this.committed = true;
-    this.manager._removeTransaction(this);
+    if (this.parent) {
+      this.parent._merge(this);
+      this.committed = true;
+    } else {
+      if (this.writeBuffer.size > 0 || this.deleteBuffer.size > 0) {
+        this._merge(this);
+        this.writeBuffer.clear();
+        this.deleteBuffer.clear();
+        this.keyVersions.clear();
+        this.localVersion = 0;
+      }
+    }
     return this;
   }
-};
-
-// src/core/sync/Manager.ts
-var SyncMVCCManager = class extends MVCCManager {
-  constructor(strategy) {
-    super(strategy);
-  }
-  createTransaction() {
-    const tx = new SyncMVCCTransaction(this, this.version);
-    this.activeTransactions.add(tx);
-    return tx;
-  }
-  _diskWrite(key, value, version) {
-    if (this.strategy.exists(key)) {
-      const oldValue = this.strategy.read(key);
-      if (!this.deletedCache.has(key)) {
-        this.deletedCache.set(key, []);
+  _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) {
+          throw new Error(`Commit conflict: Key '${key}' was modified by a newer transaction (Local v${lastModLocalVer})`);
+        }
       }
-      this.deletedCache.get(key).push({ value: oldValue, deletedAtVersion: version });
-    }
-    this.strategy.write(key, value);
-    if (!this.versionIndex.has(key)) {
-      this.versionIndex.set(key, []);
+      for (const key of child.deleteBuffer) {
+        const lastModLocalVer = this.keyVersions.get(key);
+        if (lastModLocalVer !== void 0 && lastModLocalVer > child.snapshotLocalVersion) {
+          throw new Error(`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.write(key, child.writeBuffer.get(key));
+        this.keyVersions.set(key, newLocalVersion);
+      }
+      for (const key of child.deleteBuffer) {
+        this.delete(key);
+        this.keyVersions.set(key, newLocalVersion);
+      }
+      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) {
+            throw new Error(`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();
     }
+  }
+  // --- 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) {
-    if (!this.versionIndex.has(key) && !this.deletedCache.has(key)) {
-      if (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 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;
   }
   _diskDelete(key, snapshotVersion) {
-    if (this.strategy.exists(key)) {
-      const data = this.strategy.read(key);
-      if (!this.deletedCache.has(key)) {
-        this.deletedCache.set(key, []);
-      }
-      this.deletedCache.get(key).push({ deletedAtVersion: snapshotVersion, value: data });
-      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 (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
@@ -495,139 +546,198 @@ 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);
+    });
+  }
+  createNested() {
+    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 () => {
+    return this.writeLock(async () => {
       if (this.committed) throw new Error("Transaction already committed");
-      await this.manager._commit(this);
-      this.committed = true;
-      this.manager._removeTransaction(this);
+      if (this.parent) {
+        await this.parent._merge(this);
+        this.committed = true;
+      } else {
+        if (this.writeBuffer.size > 0 || this.deleteBuffer.size > 0) {
+          await this._merge(this);
+          this.writeBuffer.clear();
+          this.deleteBuffer.clear();
+          this.keyVersions.clear();
+          this.localVersion = 0;
+        }
+      }
       return this;
     });
   }
-};
-
-// 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) {
+            throw new Error(`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) {
+            throw new Error(`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.write(key, child.writeBuffer.get(key));
+          this.keyVersions.set(key, newLocalVersion);
+        }
+        for (const key of child.deleteBuffer) {
+          this.delete(key);
+          this.keyVersions.set(key, newLocalVersion);
+        }
+        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) {
+              throw new Error(`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();
+      }
     });
   }
+  // --- 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 {
-};
 export {
-  AsyncMVCCManager,
   AsyncMVCCStrategy,
   AsyncMVCCTransaction,
-  SyncMVCCManager,
   SyncMVCCStrategy,
   SyncMVCCTransaction
 };