@liorandb/core 1.0.17 → 1.0.19

package/dist/index.js

@@ -1,20 +1,18 @@
 // src/LioranManager.ts
-import path7 from "path";
-import fs7 from "fs";
+import path9 from "path";
+import fs9 from "fs";
 import process2 from "process";
 
 // src/core/database.ts
-import path4 from "path";
-import fs4 from "fs";
-import { execFile } from "child_process";
-import { promisify } from "util";
+import path6 from "path";
+import fs6 from "fs";
 
 // src/core/collection.ts
 import { ClassicLevel as ClassicLevel3 } from "classic-level";
 
 // src/core/query.ts
-function getByPath(obj, path8) {
-  return path8.split(".").reduce((o, p) => o ? o[p] : void 0, obj);
+function getByPath(obj, path10) {
+  return path10.split(".").reduce((o, p) => o ? o[p] : void 0, obj);
 }
 function matchDocument(doc, query) {
   for (const key of Object.keys(query)) {
@@ -295,12 +293,13 @@ var Index = class {
 
 // src/core/compaction.ts
 var TMP_SUFFIX = "__compact_tmp";
-var OLD_SUFFIX = "__old";
+var OLD_SUFFIX = "__compact_old";
+var INDEX_DIR = "__indexes";
 async function compactCollectionEngine(col) {
-  await crashRecovery(col.dir);
   const baseDir = col.dir;
   const tmpDir = baseDir + TMP_SUFFIX;
   const oldDir = baseDir + OLD_SUFFIX;
+  await crashRecovery(baseDir);
   safeRemove(tmpDir);
   safeRemove(oldDir);
   await snapshotRebuild(col, tmpDir);
@@ -309,9 +308,13 @@ async function compactCollectionEngine(col) {
 }
 async function snapshotRebuild(col, tmpDir) {
   fs2.mkdirSync(tmpDir, { recursive: true });
-  const tmpDB = new ClassicLevel2(tmpDir, { valueEncoding: "utf8" });
+  const tmpDB = new ClassicLevel2(tmpDir, {
+    valueEncoding: "utf8"
+  });
   for await (const [key, val] of col.db.iterator()) {
-    await tmpDB.put(key, val);
+    if (val !== void 0) {
+      await tmpDB.put(key, val);
+    }
   }
   await tmpDB.close();
   await col.db.close();
@@ -323,38 +326,44 @@ function atomicSwap(base, tmp, old) {
 async function crashRecovery(baseDir) {
   const tmp = baseDir + TMP_SUFFIX;
   const old = baseDir + OLD_SUFFIX;
-  if (fs2.existsSync(tmp) && fs2.existsSync(old)) {
+  const baseExists = fs2.existsSync(baseDir);
+  const tmpExists = fs2.existsSync(tmp);
+  const oldExists = fs2.existsSync(old);
+  if (tmpExists && oldExists) {
     safeRemove(baseDir);
     fs2.renameSync(tmp, baseDir);
     safeRemove(old);
+    return;
   }
-  if (fs2.existsSync(old) && !fs2.existsSync(baseDir)) {
+  if (!baseExists && oldExists) {
     fs2.renameSync(old, baseDir);
+    return;
   }
-  if (fs2.existsSync(tmp) && !fs2.existsSync(old)) {
+  if (tmpExists && !oldExists) {
     safeRemove(tmp);
   }
 }
 async function rebuildIndexes(col) {
-  const indexRoot = path2.join(col.dir, "__indexes");
-  safeRemove(indexRoot);
-  fs2.mkdirSync(indexRoot, { recursive: true });
+  const indexRoot = path2.join(col.dir, INDEX_DIR);
   for (const idx of col["indexes"].values()) {
     try {
       await idx.close();
     } catch {
     }
   }
+  safeRemove(indexRoot);
+  fs2.mkdirSync(indexRoot, { recursive: true });
   const newIndexes = /* @__PURE__ */ new Map();
   for (const idx of col["indexes"].values()) {
-    const fresh = new Index(col.dir, idx.field, {
+    const rebuilt = new Index(col.dir, idx.field, {
       unique: idx.unique
     });
     for await (const [, enc] of col.db.iterator()) {
+      if (!enc) continue;
       const doc = decryptData(enc);
-      await fresh.insert(doc);
+      await rebuilt.insert(doc);
     }
-    newIndexes.set(idx.field, fresh);
+    newIndexes.set(idx.field, rebuilt);
   }
   col["indexes"] = newIndexes;
 }
@@ -370,26 +379,43 @@ var Collection = class {
   db;
   queue = Promise.resolve();
   schema;
+  schemaVersion = 1;
+  migrations = [];
   indexes = /* @__PURE__ */ new Map();
-  constructor(dir, schema) {
+  constructor(dir, schema, schemaVersion = 1) {
     this.dir = dir;
     this.db = new ClassicLevel3(dir, { valueEncoding: "utf8" });
     this.schema = schema;
+    this.schemaVersion = schemaVersion;
   }
-  /* ---------------------- INDEX MANAGEMENT ---------------------- */
-  registerIndex(index) {
-    this.indexes.set(index.field, index);
-  }
-  getIndex(field) {
-    return this.indexes.get(field);
-  }
-  /* -------------------------- CORE -------------------------- */
-  setSchema(schema) {
+  /* ===================== SCHEMA ===================== */
+  setSchema(schema, version) {
     this.schema = schema;
+    this.schemaVersion = version;
+  }
+  addMigration(migration) {
+    this.migrations.push(migration);
+    this.migrations.sort((a, b) => a.from - b.from);
   }
   validate(doc) {
     return this.schema ? validateSchema(this.schema, doc) : doc;
   }
+  migrateIfNeeded(doc) {
+    let currentVersion = doc.__v ?? 1;
+    if (currentVersion === this.schemaVersion) {
+      return doc;
+    }
+    let working = doc;
+    for (const migration of this.migrations) {
+      if (migration.from === currentVersion) {
+        working = migration.migrate(working);
+        currentVersion = migration.to;
+      }
+    }
+    working.__v = this.schemaVersion;
+    return this.validate(working);
+  }
+  /* ===================== QUEUE ===================== */
   _enqueue(task) {
     this.queue = this.queue.then(task).catch(console.error);
     return this.queue;
@@ -406,7 +432,19 @@ var Collection = class {
     } catch {
     }
   }
-  /* -------------------- COMPACTION ENGINE -------------------- */
+  /* ===================== INDEX MANAGEMENT ===================== */
+  registerIndex(index) {
+    this.indexes.set(index.field, index);
+  }
+  getIndex(field) {
+    return this.indexes.get(field);
+  }
+  async _updateIndexes(oldDoc, newDoc) {
+    for (const index of this.indexes.values()) {
+      await index.update(oldDoc, newDoc);
+    }
+  }
+  /* ===================== COMPACTION ===================== */
   async compact() {
     return this._enqueue(async () => {
       try {
@@ -418,6 +456,7 @@ var Collection = class {
       await rebuildIndexes(this);
     });
   }
+  /* ===================== INTERNAL EXEC ===================== */
   async _exec(op, args) {
     switch (op) {
       case "insertOne":
@@ -442,16 +481,14 @@ var Collection = class {
         throw new Error(`Unknown operation: ${op}`);
     }
   }
-  /* ------------------ INDEX HOOK ------------------ */
-  async _updateIndexes(oldDoc, newDoc) {
-    for (const index of this.indexes.values()) {
-      await index.update(oldDoc, newDoc);
-    }
-  }
-  /* ---------------- Storage ---------------- */
+  /* ===================== STORAGE ===================== */
   async _insertOne(doc) {
     const _id = doc._id ?? uuid();
-    const final = this.validate({ _id, ...doc });
+    const final = this.validate({
+      _id,
+      ...doc,
+      __v: this.schemaVersion
+    });
     await this.db.put(String(_id), encryptData(final));
     await this._updateIndexes(null, final);
     return final;
@@ -461,7 +498,11 @@ var Collection = class {
     const out = [];
     for (const d of docs) {
       const _id = d._id ?? uuid();
-      const final = this.validate({ _id, ...d });
+      const final = this.validate({
+        _id,
+        ...d,
+        __v: this.schemaVersion
+      });
       batch.push({
         type: "put",
         key: String(_id),
@@ -475,7 +516,7 @@ var Collection = class {
     }
     return out;
   }
-  /* ---------------- QUERY ENGINE (INDEXED) ---------------- */
+  /* ===================== QUERY ===================== */
   async _getCandidateIds(query) {
     const indexedFields = new Set(this.indexes.keys());
     return runIndexedQuery(
@@ -497,15 +538,26 @@ var Collection = class {
       }
     );
   }
+  async _readAndMigrate(id) {
+    const enc = await this.db.get(id);
+    if (!enc) return null;
+    const raw = decryptData(enc);
+    const migrated = this.migrateIfNeeded(raw);
+    if (raw.__v !== this.schemaVersion) {
+      await this.db.put(id, encryptData(migrated));
+      await this._updateIndexes(raw, migrated);
+    }
+    return migrated;
+  }
   async _find(query) {
     const ids = await this._getCandidateIds(query);
     const out = [];
     for (const id of ids) {
       try {
-        const enc = await this.db.get(id);
-        if (!enc) continue;
-        const doc = decryptData(enc);
-        if (matchDocument(doc, query)) out.push(doc);
+        const doc = await this._readAndMigrate(id);
+        if (doc && matchDocument(doc, query)) {
+          out.push(doc);
+        }
       } catch {
       }
     }
@@ -514,8 +566,7 @@ var Collection = class {
   async _findOne(query) {
     if (query?._id) {
       try {
-        const enc = await this.db.get(String(query._id));
-        return enc ? decryptData(enc) : null;
+        return await this._readAndMigrate(String(query._id));
       } catch {
         return null;
       }
@@ -523,10 +574,10 @@ var Collection = class {
     const ids = await this._getCandidateIds(query);
     for (const id of ids) {
       try {
-        const enc = await this.db.get(id);
-        if (!enc) continue;
-        const doc = decryptData(enc);
-        if (matchDocument(doc, query)) return doc;
+        const doc = await this._readAndMigrate(id);
+        if (doc && matchDocument(doc, query)) {
+          return doc;
+        }
       } catch {
       }
     }
@@ -537,40 +588,34 @@ var Collection = class {
     let count = 0;
     for (const id of ids) {
       try {
-        const enc = await this.db.get(id);
-        if (!enc) continue;
-        if (matchDocument(decryptData(enc), filter)) count++;
+        const doc = await this._readAndMigrate(id);
+        if (doc && matchDocument(doc, filter)) {
+          count++;
+        }
       } catch {
       }
     }
     return count;
   }
-  /* ---------------- UPDATE ---------------- */
+  /* ===================== UPDATE ===================== */
   async _updateOne(filter, update, options) {
     const ids = await this._getCandidateIds(filter);
     for (const id of ids) {
-      try {
-        const enc = await this.db.get(id);
-        if (!enc) continue;
-        const value = decryptData(enc);
-        if (matchDocument(value, filter)) {
-          const updated = this.validate(applyUpdate(value, update));
-          updated._id = value._id;
-          await this.db.put(id, encryptData(updated));
-          await this._updateIndexes(value, updated);
-          return updated;
-        }
-      } catch {
+      const existing = await this._readAndMigrate(id);
+      if (!existing) continue;
+      if (matchDocument(existing, filter)) {
+        const updated = this.validate({
+          ...applyUpdate(existing, update),
+          _id: existing._id,
+          __v: this.schemaVersion
+        });
+        await this.db.put(id, encryptData(updated));
+        await this._updateIndexes(existing, updated);
+        return updated;
       }
     }
     if (options?.upsert) {
-      const doc = this.validate({
-        _id: uuid(),
-        ...applyUpdate({}, update)
-      });
-      await this.db.put(String(doc._id), encryptData(doc));
-      await this._updateIndexes(null, doc);
-      return doc;
+      return this._insertOne(applyUpdate({}, update));
     }
     return null;
   }
@@ -578,36 +623,31 @@ var Collection = class {
     const ids = await this._getCandidateIds(filter);
     const out = [];
     for (const id of ids) {
-      try {
-        const enc = await this.db.get(id);
-        if (!enc) continue;
-        const value = decryptData(enc);
-        if (matchDocument(value, filter)) {
-          const updated = this.validate(applyUpdate(value, update));
-          updated._id = value._id;
-          await this.db.put(id, encryptData(updated));
-          await this._updateIndexes(value, updated);
-          out.push(updated);
-        }
-      } catch {
+      const existing = await this._readAndMigrate(id);
+      if (!existing) continue;
+      if (matchDocument(existing, filter)) {
+        const updated = this.validate({
+          ...applyUpdate(existing, update),
+          _id: existing._id,
+          __v: this.schemaVersion
+        });
+        await this.db.put(id, encryptData(updated));
+        await this._updateIndexes(existing, updated);
+        out.push(updated);
       }
     }
     return out;
   }
-  /* ---------------- DELETE ---------------- */
+  /* ===================== DELETE ===================== */
   async _deleteOne(filter) {
     const ids = await this._getCandidateIds(filter);
     for (const id of ids) {
-      try {
-        const enc = await this.db.get(id);
-        if (!enc) continue;
-        const value = decryptData(enc);
-        if (matchDocument(value, filter)) {
-          await this.db.del(id);
-          await this._updateIndexes(value, null);
-          return true;
-        }
-      } catch {
+      const existing = await this._readAndMigrate(id);
+      if (!existing) continue;
+      if (matchDocument(existing, filter)) {
+        await this.db.del(id);
+        await this._updateIndexes(existing, null);
+        return true;
       }
     }
     return false;
@@ -616,21 +656,17 @@ var Collection = class {
     const ids = await this._getCandidateIds(filter);
     let count = 0;
     for (const id of ids) {
-      try {
-        const enc = await this.db.get(id);
-        if (!enc) continue;
-        const value = decryptData(enc);
-        if (matchDocument(value, filter)) {
-          await this.db.del(id);
-          await this._updateIndexes(value, null);
-          count++;
-        }
-      } catch {
+      const existing = await this._readAndMigrate(id);
+      if (!existing) continue;
+      if (matchDocument(existing, filter)) {
+        await this.db.del(id);
+        await this._updateIndexes(existing, null);
+        count++;
       }
     }
     return count;
   }
-  /* ---------------- PUBLIC API (Mongo-style) ---------------- */
+  /* ===================== PUBLIC API ===================== */
   insertOne(doc) {
     return this._enqueue(() => this._exec("insertOne", [doc]));
   }
@@ -793,10 +829,230 @@ var MigrationEngine = class {
   }
 };
 
+// src/core/wal.ts
+import fs4 from "fs";
+import path4 from "path";
+var MAX_WAL_SIZE = 16 * 1024 * 1024;
+var WAL_DIR = "__wal";
+var CRC32_TABLE = (() => {
+  const table = new Uint32Array(256);
+  for (let i = 0; i < 256; i++) {
+    let c = i;
+    for (let k = 0; k < 8; k++) {
+      c = c & 1 ? 3988292384 ^ c >>> 1 : c >>> 1;
+    }
+    table[i] = c >>> 0;
+  }
+  return table;
+})();
+function crc32(input) {
+  let crc = 4294967295;
+  for (let i = 0; i < input.length; i++) {
+    const byte = input.charCodeAt(i);
+    crc = CRC32_TABLE[(crc ^ byte) & 255] ^ crc >>> 8;
+  }
+  return (crc ^ 4294967295) >>> 0;
+}
+var WALManager = class {
+  walDir;
+  currentGen = 1;
+  lsn = 0;
+  fd = null;
+  constructor(baseDir) {
+    this.walDir = path4.join(baseDir, WAL_DIR);
+    fs4.mkdirSync(this.walDir, { recursive: true });
+    this.currentGen = this.detectLastGeneration();
+  }
+  /* -------------------------
+     INTERNAL HELPERS
+  ------------------------- */
+  walPath(gen = this.currentGen) {
+    return path4.join(
+      this.walDir,
+      `wal-${String(gen).padStart(6, "0")}.log`
+    );
+  }
+  detectLastGeneration() {
+    if (!fs4.existsSync(this.walDir)) return 1;
+    const files = fs4.readdirSync(this.walDir);
+    let max = 0;
+    for (const f of files) {
+      const m = f.match(/^wal-(\d+)\.log$/);
+      if (m) max = Math.max(max, Number(m[1]));
+    }
+    return max || 1;
+  }
+  async open() {
+    if (!this.fd) {
+      this.fd = await fs4.promises.open(this.walPath(), "a");
+    }
+  }
+  async rotate() {
+    if (this.fd) {
+      await this.fd.close();
+      this.fd = null;
+    }
+    this.currentGen++;
+  }
+  /* -------------------------
+     APPEND
+  ------------------------- */
+  async append(record) {
+    await this.open();
+    const full = {
+      ...record,
+      lsn: ++this.lsn
+    };
+    const body = JSON.stringify(full);
+    const stored = {
+      ...full,
+      crc: crc32(body)
+    };
+    await this.fd.write(JSON.stringify(stored) + "\n");
+    await this.fd.sync();
+    const stat = await this.fd.stat();
+    if (stat.size >= MAX_WAL_SIZE) {
+      await this.rotate();
+    }
+    return full.lsn;
+  }
+  /* -------------------------
+     REPLAY
+  ------------------------- */
+  async replay(fromLSN, apply) {
+    if (!fs4.existsSync(this.walDir)) return;
+    const files = fs4.readdirSync(this.walDir).filter((f) => f.startsWith("wal-")).sort();
+    for (const file of files) {
+      const filePath = path4.join(this.walDir, file);
+      const data = fs4.readFileSync(filePath, "utf8");
+      const lines = data.split("\n");
+      for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        if (!line.trim()) continue;
+        let parsed;
+        try {
+          parsed = JSON.parse(line);
+        } catch {
+          console.error("WAL parse error, stopping replay");
+          return;
+        }
+        const { crc, ...record } = parsed;
+        const expected = crc32(JSON.stringify(record));
+        if (expected !== crc) {
+          console.error(
+            "WAL checksum mismatch, stopping replay",
+            { file, line: i + 1 }
+          );
+          return;
+        }
+        if (record.lsn <= fromLSN) continue;
+        this.lsn = Math.max(this.lsn, record.lsn);
+        await apply(record);
+      }
+    }
+  }
+  /* -------------------------
+     CLEANUP
+  ------------------------- */
+  async cleanup(beforeGen) {
+    if (!fs4.existsSync(this.walDir)) return;
+    const files = fs4.readdirSync(this.walDir);
+    for (const f of files) {
+      const m = f.match(/^wal-(\d+)\.log$/);
+      if (!m) continue;
+      const gen = Number(m[1]);
+      if (gen < beforeGen) {
+        fs4.unlinkSync(path4.join(this.walDir, f));
+      }
+    }
+  }
+  /* -------------------------
+     GETTERS
+  ------------------------- */
+  getCurrentLSN() {
+    return this.lsn;
+  }
+  getCurrentGen() {
+    return this.currentGen;
+  }
+};
+
+// src/core/checkpoint.ts
+import fs5 from "fs";
+import path5 from "path";
+var CHECKPOINT_FILE = "__checkpoint.json";
+var TMP_SUFFIX2 = ".tmp";
+var FORMAT_VERSION = 1;
+var CheckpointManager = class {
+  filePath;
+  data;
+  constructor(baseDir) {
+    this.filePath = path5.join(baseDir, CHECKPOINT_FILE);
+    this.data = {
+      lsn: 0,
+      walGen: 1,
+      time: 0,
+      version: FORMAT_VERSION
+    };
+    this.load();
+  }
+  /* -------------------------
+     LOAD (Crash-safe)
+  ------------------------- */
+  load() {
+    if (!fs5.existsSync(this.filePath)) {
+      return;
+    }
+    try {
+      const raw = fs5.readFileSync(this.filePath, "utf8");
+      const parsed = JSON.parse(raw);
+      if (typeof parsed.lsn === "number" && typeof parsed.walGen === "number") {
+        this.data = parsed;
+      }
+    } catch {
+      console.error("Checkpoint corrupted, starting from zero");
+      this.data = {
+        lsn: 0,
+        walGen: 1,
+        time: 0,
+        version: FORMAT_VERSION
+      };
+    }
+  }
+  /* -------------------------
+     SAVE (Atomic Write)
+  ------------------------- */
+  save(lsn, walGen) {
+    const newData = {
+      lsn,
+      walGen,
+      time: Date.now(),
+      version: FORMAT_VERSION
+    };
+    const tmpPath = this.filePath + TMP_SUFFIX2;
+    try {
+      fs5.writeFileSync(
+        tmpPath,
+        JSON.stringify(newData, null, 2),
+        { encoding: "utf8" }
+      );
+      fs5.renameSync(tmpPath, this.filePath);
+      this.data = newData;
+    } catch (err) {
+      console.error("Failed to write checkpoint:", err);
+    }
+  }
+  /* -------------------------
+     GET CURRENT
+  ------------------------- */
+  get() {
+    return this.data;
+  }
+};
+
 // src/core/database.ts
-var exec = promisify(execFile);
 var META_FILE = "__db_meta.json";
-var META_VERSION = 1;
+var META_VERSION = 2;
 var DEFAULT_SCHEMA_VERSION = "v1";
 var DBTransactionContext = class {
   constructor(db, txId) {
@@ -819,11 +1075,26 @@ var DBTransactionContext = class {
     });
   }
   async commit() {
-    await this.db.writeWAL(this.ops);
-    await this.db.writeWAL([{ tx: this.txId, commit: true }]);
+    for (const op of this.ops) {
+      const recordOp = {
+        tx: this.txId,
+        type: "op",
+        payload: op
+      };
+      await this.db.wal.append(recordOp);
+    }
+    const commitRecord = {
+      tx: this.txId,
+      type: "commit"
+    };
+    await this.db.wal.append(commitRecord);
     await this.db.applyTransaction(this.ops);
-    await this.db.writeWAL([{ tx: this.txId, applied: true }]);
-    await this.db.clearWAL();
+    const appliedRecord = {
+      tx: this.txId,
+      type: "applied"
+    };
+    await this.db.wal.append(appliedRecord);
+    await this.db.postCommitMaintenance();
   }
 };
 var LioranDB = class _LioranDB {
@@ -831,26 +1102,56 @@ var LioranDB = class _LioranDB {
   dbName;
   manager;
   collections;
-  walPath;
   metaPath;
   meta;
   migrator;
   static TX_SEQ = 0;
+  wal;
+  checkpoint;
   constructor(basePath, dbName, manager) {
     this.basePath = basePath;
     this.dbName = dbName;
     this.manager = manager;
     this.collections = /* @__PURE__ */ new Map();
-    this.walPath = path4.join(basePath, "__tx_wal.log");
-    this.metaPath = path4.join(basePath, META_FILE);
-    fs4.mkdirSync(basePath, { recursive: true });
+    this.metaPath = path6.join(basePath, META_FILE);
+    fs6.mkdirSync(basePath, { recursive: true });
     this.loadMeta();
+    this.wal = new WALManager(basePath);
+    this.checkpoint = new CheckpointManager(basePath);
     this.migrator = new MigrationEngine(this);
-    this.recoverFromWAL().catch(console.error);
+    this.initialize().catch(console.error);
+  }
+  /* ------------------------- INIT & RECOVERY ------------------------- */
+  async initialize() {
+    await this.recoverFromWAL();
+  }
+  async recoverFromWAL() {
+    const checkpointData = this.checkpoint.get();
+    const fromLSN = checkpointData.lsn;
+    const committed = /* @__PURE__ */ new Set();
+    const applied = /* @__PURE__ */ new Set();
+    const ops = /* @__PURE__ */ new Map();
+    await this.wal.replay(fromLSN, async (record) => {
+      if (record.type === "commit") {
+        committed.add(record.tx);
+      } else if (record.type === "applied") {
+        applied.add(record.tx);
+      } else if (record.type === "op") {
+        if (!ops.has(record.tx)) ops.set(record.tx, []);
+        ops.get(record.tx).push(record.payload);
+      }
+    });
+    for (const tx of committed) {
+      if (applied.has(tx)) continue;
+      const txOps = ops.get(tx);
+      if (txOps) {
+        await this.applyTransaction(txOps);
+      }
+    }
   }
   /* ------------------------- META ------------------------- */
   loadMeta() {
-    if (!fs4.existsSync(this.metaPath)) {
+    if (!fs6.existsSync(this.metaPath)) {
       this.meta = {
         version: META_VERSION,
         indexes: {},
@@ -859,14 +1160,14 @@ var LioranDB = class _LioranDB {
       this.saveMeta();
       return;
     }
-    this.meta = JSON.parse(fs4.readFileSync(this.metaPath, "utf8"));
+    this.meta = JSON.parse(fs6.readFileSync(this.metaPath, "utf8"));
     if (!this.meta.schemaVersion) {
       this.meta.schemaVersion = DEFAULT_SCHEMA_VERSION;
       this.saveMeta();
     }
   }
   saveMeta() {
-    fs4.writeFileSync(this.metaPath, JSON.stringify(this.meta, null, 2));
+    fs6.writeFileSync(this.metaPath, JSON.stringify(this.meta, null, 2));
   }
   getSchemaVersion() {
     return this.meta.schemaVersion;
@@ -875,7 +1176,7 @@ var LioranDB = class _LioranDB {
     this.meta.schemaVersion = v;
     this.saveMeta();
   }
-  /* ------------------------- MIGRATION API ------------------------- */
+  /* ------------------------- DB MIGRATIONS ------------------------- */
   migrate(from, to, fn) {
     this.migrator.register(from, to, async (db) => {
       await fn(db);
@@ -885,44 +1186,7 @@ var LioranDB = class _LioranDB {
   async applyMigrations(targetVersion) {
     await this.migrator.upgradeToLatest();
   }
-  /* ------------------------- WAL ------------------------- */
-  async writeWAL(entries) {
-    const fd = await fs4.promises.open(this.walPath, "a");
-    for (const e of entries) {
-      await fd.write(JSON.stringify(e) + "\n");
-    }
-    await fd.sync();
-    await fd.close();
-  }
-  async clearWAL() {
-    try {
-      await fs4.promises.unlink(this.walPath);
-    } catch {
-    }
-  }
-  async recoverFromWAL() {
-    if (!fs4.existsSync(this.walPath)) return;
-    const raw = await fs4.promises.readFile(this.walPath, "utf8");
-    const committed = /* @__PURE__ */ new Set();
-    const applied = /* @__PURE__ */ new Set();
-    const ops = /* @__PURE__ */ new Map();
-    for (const line of raw.split("\n")) {
-      if (!line.trim()) continue;
-      const entry = JSON.parse(line);
-      if ("commit" in entry) committed.add(entry.tx);
-      else if ("applied" in entry) applied.add(entry.tx);
-      else {
-        if (!ops.has(entry.tx)) ops.set(entry.tx, []);
-        ops.get(entry.tx).push(entry);
-      }
-    }
-    for (const tx of committed) {
-      if (applied.has(tx)) continue;
-      const txOps = ops.get(tx);
-      if (txOps) await this.applyTransaction(txOps);
-    }
-    await this.clearWAL();
-  }
+  /* ------------------------- TX APPLY ------------------------- */
   async applyTransaction(ops) {
     for (const { col, op, args } of ops) {
       const collection = this.collection(col);
@@ -930,15 +1194,21 @@ var LioranDB = class _LioranDB {
     }
   }
   /* ------------------------- COLLECTION ------------------------- */
-  collection(name, schema) {
+  collection(name, schema, schemaVersion) {
     if (this.collections.has(name)) {
       const col2 = this.collections.get(name);
-      if (schema) col2.setSchema(schema);
+      if (schema && schemaVersion !== void 0) {
+        col2.setSchema(schema, schemaVersion);
+      }
       return col2;
     }
-    const colPath = path4.join(this.basePath, name);
-    fs4.mkdirSync(colPath, { recursive: true });
-    const col = new Collection(colPath, schema);
+    const colPath = path6.join(this.basePath, name);
+    fs6.mkdirSync(colPath, { recursive: true });
+    const col = new Collection(
+      colPath,
+      schema,
+      schemaVersion ?? 1
+    );
     const metas = this.meta.indexes[name] ?? [];
     for (const m of metas) {
       col.registerIndex(new Index(colPath, m.field, m.options));
@@ -955,11 +1225,11 @@ var LioranDB = class _LioranDB {
     for await (const [key, enc] of col.db.iterator()) {
       if (!enc) continue;
       try {
-        const doc = decryptData2(enc);
+        const doc = decryptData(enc);
         await index.insert(doc);
       } catch (err) {
-        const errorMessage = err instanceof Error ? err.message : String(err);
-        console.warn(`Could not decrypt document ${key} during index build: ${errorMessage}`);
+        const msg = err instanceof Error ? err.message : String(err);
+        console.warn(`Index build skipped doc ${key}: ${msg}`);
       }
     }
     col.registerIndex(index);
@@ -971,12 +1241,10 @@ var LioranDB = class _LioranDB {
   }
   /* ------------------------- COMPACTION ------------------------- */
   async compactCollection(name) {
-    await this.clearWAL();
     const col = this.collection(name);
     await col.compact();
   }
   async compactAll() {
-    await this.clearWAL();
     for (const name of this.collections.keys()) {
       await this.compactCollection(name);
     }
@@ -989,6 +1257,9 @@ var LioranDB = class _LioranDB {
     await tx.commit();
     return result;
   }
+  /* ------------------------- POST COMMIT ------------------------- */
+  async postCommitMaintenance() {
+  }
   /* ------------------------- SHUTDOWN ------------------------- */
   async close() {
     for (const col of this.collections.values()) {
@@ -1000,21 +1271,18 @@ var LioranDB = class _LioranDB {
     this.collections.clear();
   }
 };
-function decryptData2(enc) {
-  throw new Error("Function not implemented.");
-}
 
 // src/utils/rootpath.ts
 import os2 from "os";
-import path5 from "path";
-import fs5 from "fs";
+import path7 from "path";
+import fs7 from "fs";
 function getDefaultRootPath() {
   let dbPath = process.env.LIORANDB_PATH;
   if (!dbPath) {
     const homeDir = os2.homedir();
-    dbPath = path5.join(homeDir, "LioranDB", "db");
-    if (!fs5.existsSync(dbPath)) {
-      fs5.mkdirSync(dbPath, { recursive: true });
+    dbPath = path7.join(homeDir, "LioranDB", "db");
+    if (!fs7.existsSync(dbPath)) {
+      fs7.mkdirSync(dbPath, { recursive: true });
     }
     process.env.LIORANDB_PATH = dbPath;
   }
@@ -1029,24 +1297,24 @@ import net from "net";
 
 // src/ipc/socketPath.ts
 import os3 from "os";
-import path6 from "path";
+import path8 from "path";
 function getIPCSocketPath(rootPath) {
   if (os3.platform() === "win32") {
     return `\\\\.\\pipe\\liorandb_${rootPath.replace(/[:\\\/]/g, "_")}`;
   }
-  return path6.join(rootPath, ".lioran.sock");
+  return path8.join(rootPath, ".lioran.sock");
 }
 
 // src/ipc/client.ts
 function delay(ms) {
   return new Promise((r) => setTimeout(r, ms));
 }
-async function connectWithRetry(path8) {
+async function connectWithRetry(path10) {
   let attempt = 0;
   while (true) {
     try {
       return await new Promise((resolve, reject) => {
-        const socket = net.connect(path8, () => resolve(socket));
+        const socket = net.connect(path10, () => resolve(socket));
         socket.once("error", reject);
       });
     } catch (err) {
@@ -1129,11 +1397,11 @@ var DBQueue = class {
     return this.exec("compact:all", {});
   }
   /* ----------------------------- SNAPSHOT API ----------------------------- */
-  snapshot(path8) {
-    return this.exec("snapshot", { path: path8 });
+  snapshot(path10) {
+    return this.exec("snapshot", { path: path10 });
   }
-  restore(path8) {
-    return this.exec("restore", { path: path8 });
+  restore(path10) {
+    return this.exec("restore", { path: path10 });
   }
   /* ------------------------------ SHUTDOWN ------------------------------ */
   async shutdown() {
@@ -1148,7 +1416,7 @@ var dbQueue = new DBQueue();
 
 // src/ipc/server.ts
 import net2 from "net";
-import fs6 from "fs";
+import fs8 from "fs";
 var IPCServer = class {
   server;
   manager;
@@ -1159,7 +1427,7 @@ var IPCServer = class {
   }
   start() {
     if (!this.socketPath.startsWith("\\\\.\\")) {
-      if (fs6.existsSync(this.socketPath)) fs6.unlinkSync(this.socketPath);
+      if (fs8.existsSync(this.socketPath)) fs8.unlinkSync(this.socketPath);
     }
     this.server = net2.createServer((socket) => {
       let buffer = "";
@@ -1261,7 +1529,7 @@ var IPCServer = class {
     if (this.server) this.server.close();
     if (!this.socketPath.startsWith("\\\\.\\")) {
       try {
-        fs6.unlinkSync(this.socketPath);
+        fs8.unlinkSync(this.socketPath);
       } catch {
       }
     }
@@ -1279,8 +1547,8 @@ var LioranManager = class {
   constructor(options = {}) {
     const { rootPath, encryptionKey } = options;
     this.rootPath = rootPath || getDefaultRootPath();
-    if (!fs7.existsSync(this.rootPath)) {
-      fs7.mkdirSync(this.rootPath, { recursive: true });
+    if (!fs9.existsSync(this.rootPath)) {
+      fs9.mkdirSync(this.rootPath, { recursive: true });
     }
     if (encryptionKey) {
       setEncryptionKey(encryptionKey);
@@ -1303,18 +1571,18 @@ var LioranManager = class {
     }
   }
   tryAcquireLock() {
-    const lockPath = path7.join(this.rootPath, ".lioran.lock");
+    const lockPath = path9.join(this.rootPath, ".lioran.lock");
     try {
-      this.lockFd = fs7.openSync(lockPath, "wx");
-      fs7.writeSync(this.lockFd, String(process2.pid));
+      this.lockFd = fs9.openSync(lockPath, "wx");
+      fs9.writeSync(this.lockFd, String(process2.pid));
       return true;
     } catch {
       try {
-        const pid = Number(fs7.readFileSync(lockPath, "utf8"));
+        const pid = Number(fs9.readFileSync(lockPath, "utf8"));
         if (!this.isProcessAlive(pid)) {
-          fs7.unlinkSync(lockPath);
-          this.lockFd = fs7.openSync(lockPath, "wx");
-          fs7.writeSync(this.lockFd, String(process2.pid));
+          fs9.unlinkSync(lockPath);
+          this.lockFd = fs9.openSync(lockPath, "wx");
+          fs9.writeSync(this.lockFd, String(process2.pid));
           return true;
         }
       } catch {
@@ -1335,8 +1603,8 @@ var LioranManager = class {
     if (this.openDBs.has(name)) {
       return this.openDBs.get(name);
     }
-    const dbPath = path7.join(this.rootPath, name);
-    await fs7.promises.mkdir(dbPath, { recursive: true });
+    const dbPath = path9.join(this.rootPath, name);
+    await fs9.promises.mkdir(dbPath, { recursive: true });
     const db = new LioranDB(dbPath, name, this);
     this.openDBs.set(name, db);
     return db;
@@ -1357,7 +1625,7 @@ var LioranManager = class {
         }
       }
     }
-    fs7.mkdirSync(path7.dirname(snapshotPath), { recursive: true });
+    fs9.mkdirSync(path9.dirname(snapshotPath), { recursive: true });
     const tar = await import("tar");
     await tar.c({
       gzip: true,
@@ -1375,8 +1643,8 @@ var LioranManager = class {
       return dbQueue.exec("restore", { path: snapshotPath });
     }
     await this.closeAll();
-    fs7.rmSync(this.rootPath, { recursive: true, force: true });
-    fs7.mkdirSync(this.rootPath, { recursive: true });
+    fs9.rmSync(this.rootPath, { recursive: true, force: true });
+    fs9.mkdirSync(this.rootPath, { recursive: true });
     const tar = await import("tar");
     await tar.x({
       file: snapshotPath,
@@ -1401,8 +1669,8 @@ var LioranManager = class {
     }
     this.openDBs.clear();
     try {
-      if (this.lockFd) fs7.closeSync(this.lockFd);
-      fs7.unlinkSync(path7.join(this.rootPath, ".lioran.lock"));
+      if (this.lockFd) fs9.closeSync(this.lockFd);
+      fs9.unlinkSync(path9.join(this.rootPath, ".lioran.lock"));
     } catch {
     }
     await this.ipcServer?.close();