@liorandb/core 1.0.19 → 1.1.0

package/dist/index.d.ts

@@ -93,6 +93,8 @@ declare class WALManager {
     constructor(baseDir: string);
     private walPath;
     private detectLastGeneration;
+    private recoverLSNFromExistingLogs;
+    private getSortedWalFiles;
     private open;
     private rotate;
     append(record: Omit<WALRecord, "lsn">): Promise<number>;
@@ -130,6 +132,7 @@ declare class LioranDB {
     constructor(basePath: string, dbName: string, manager: LioranManager);
     private initialize;
     private recoverFromWAL;
+    advanceCheckpoint(lsn: number): void;
     private loadMeta;
     private saveMeta;
     getSchemaVersion(): string;

package/dist/index.js

@@ -303,8 +303,10 @@ async function compactCollectionEngine(col) {
   safeRemove(tmpDir);
   safeRemove(oldDir);
   await snapshotRebuild(col, tmpDir);
-  atomicSwap(baseDir, tmpDir, oldDir);
+  await atomicSwap(baseDir, tmpDir, oldDir);
   safeRemove(oldDir);
+  await reopenCollectionDB(col);
+  await rebuildIndexes(col);
 }
 async function snapshotRebuild(col, tmpDir) {
   fs2.mkdirSync(tmpDir, { recursive: true });
@@ -319,9 +321,16 @@ async function snapshotRebuild(col, tmpDir) {
   await tmpDB.close();
   await col.db.close();
 }
-function atomicSwap(base, tmp, old) {
+async function atomicSwap(base, tmp, old) {
   fs2.renameSync(base, old);
-  fs2.renameSync(tmp, base);
+  try {
+    fs2.renameSync(tmp, base);
+  } catch (err) {
+    if (fs2.existsSync(old)) {
+      fs2.renameSync(old, base);
+    }
+    throw err;
+  }
 }
 async function crashRecovery(baseDir) {
   const tmp = baseDir + TMP_SUFFIX;
@@ -343,9 +352,15 @@ async function crashRecovery(baseDir) {
     safeRemove(tmp);
   }
 }
+async function reopenCollectionDB(col) {
+  col.db = new ClassicLevel2(col.dir, {
+    valueEncoding: "utf8"
+  });
+}
 async function rebuildIndexes(col) {
   const indexRoot = path2.join(col.dir, INDEX_DIR);
-  for (const idx of col["indexes"].values()) {
+  const oldIndexes = new Map(col["indexes"]);
+  for (const idx of oldIndexes.values()) {
     try {
       await idx.close();
     } catch {
@@ -353,19 +368,22 @@ async function rebuildIndexes(col) {
   }
   safeRemove(indexRoot);
   fs2.mkdirSync(indexRoot, { recursive: true });
-  const newIndexes = /* @__PURE__ */ new Map();
-  for (const idx of col["indexes"].values()) {
+  const rebuiltIndexes = /* @__PURE__ */ new Map();
+  for (const idx of oldIndexes.values()) {
     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 rebuilt.insert(doc);
+      try {
+        const doc = decryptData(enc);
+        await rebuilt.insert(doc);
+      } catch {
+      }
     }
-    newIndexes.set(idx.field, rebuilt);
+    rebuiltIndexes.set(idx.field, rebuilt);
   }
-  col["indexes"] = newIndexes;
+  col["indexes"] = rebuiltIndexes;
 }
 function safeRemove(p) {
   if (fs2.existsSync(p)) {
@@ -848,8 +866,7 @@ var CRC32_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;
+    crc = CRC32_TABLE[(crc ^ input.charCodeAt(i)) & 255] ^ crc >>> 8;
   }
   return (crc ^ 4294967295) >>> 0;
 }
@@ -862,6 +879,7 @@ var WALManager = class {
     this.walDir = path4.join(baseDir, WAL_DIR);
     fs4.mkdirSync(this.walDir, { recursive: true });
     this.currentGen = this.detectLastGeneration();
+    this.recoverLSNFromExistingLogs();
   }
   /* -------------------------
      INTERNAL HELPERS
@@ -878,10 +896,40 @@ var WALManager = class {
     let max = 0;
     for (const f of files) {
       const m = f.match(/^wal-(\d+)\.log$/);
-      if (m) max = Math.max(max, Number(m[1]));
+      if (m) {
+        const gen = Number(m[1]);
+        if (!Number.isNaN(gen)) {
+          max = Math.max(max, gen);
+        }
+      }
     }
     return max || 1;
   }
+  recoverLSNFromExistingLogs() {
+    const files = this.getSortedWalFiles();
+    for (const file of files) {
+      const filePath = path4.join(this.walDir, file);
+      const lines = fs4.readFileSync(filePath, "utf8").split("\n");
+      for (const line of lines) {
+        if (!line.trim()) continue;
+        try {
+          const parsed = JSON.parse(line);
+          const { crc, ...record } = parsed;
+          if (crc32(JSON.stringify(record)) !== crc) break;
+          this.lsn = Math.max(this.lsn, record.lsn);
+        } catch {
+          break;
+        }
+      }
+    }
+  }
+  getSortedWalFiles() {
+    return fs4.readdirSync(this.walDir).filter((f) => /^wal-\d+\.log$/.test(f)).sort((a, b) => {
+      const ga = Number(a.match(/^wal-(\d+)\.log$/)[1]);
+      const gb = Number(b.match(/^wal-(\d+)\.log$/)[1]);
+      return ga - gb;
+    });
+  }
   async open() {
     if (!this.fd) {
       this.fd = await fs4.promises.open(this.walPath(), "a");
@@ -889,13 +937,14 @@ var WALManager = class {
   }
   async rotate() {
     if (this.fd) {
+      await this.fd.sync();
       await this.fd.close();
       this.fd = null;
     }
     this.currentGen++;
   }
   /* -------------------------
-     APPEND
+     APPEND (Crash-safe)
   ------------------------- */
   async append(record) {
     await this.open();
@@ -908,7 +957,8 @@ var WALManager = class {
       ...full,
       crc: crc32(body)
     };
-    await this.fd.write(JSON.stringify(stored) + "\n");
+    const line = JSON.stringify(stored) + "\n";
+    await this.fd.write(line);
     await this.fd.sync();
     const stat = await this.fd.stat();
     if (stat.size >= MAX_WAL_SIZE) {
@@ -917,38 +967,44 @@ var WALManager = class {
     return full.lsn;
   }
   /* -------------------------
-     REPLAY
+     REPLAY (Auto-heal tail)
   ------------------------- */
   async replay(fromLSN, apply) {
     if (!fs4.existsSync(this.walDir)) return;
-    const files = fs4.readdirSync(this.walDir).filter((f) => f.startsWith("wal-")).sort();
+    const files = this.getSortedWalFiles();
     for (const file of files) {
       const filePath = path4.join(this.walDir, file);
-      const data = fs4.readFileSync(filePath, "utf8");
-      const lines = data.split("\n");
+      const fd = fs4.openSync(filePath, "r+");
+      const content = fs4.readFileSync(filePath, "utf8");
+      const lines = content.split("\n");
+      let validOffset = 0;
       for (let i = 0; i < lines.length; i++) {
         const line = lines[i];
-        if (!line.trim()) continue;
+        if (!line.trim()) {
+          validOffset += line.length + 1;
+          continue;
+        }
         let parsed;
         try {
           parsed = JSON.parse(line);
         } catch {
-          console.error("WAL parse error, stopping replay");
-          return;
+          break;
         }
         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;
+          break;
         }
+        validOffset += line.length + 1;
         if (record.lsn <= fromLSN) continue;
         this.lsn = Math.max(this.lsn, record.lsn);
         await apply(record);
       }
+      const stat = fs4.fstatSync(fd);
+      if (validOffset < stat.size) {
+        fs4.ftruncateSync(fd, validOffset);
+      }
+      fs4.closeSync(fd);
     }
   }
   /* -------------------------
@@ -980,14 +1036,32 @@ var WALManager = class {
 // src/core/checkpoint.ts
 import fs5 from "fs";
 import path5 from "path";
-var CHECKPOINT_FILE = "__checkpoint.json";
-var TMP_SUFFIX2 = ".tmp";
+var CHECKPOINT_A = "__checkpoint_A.json";
+var CHECKPOINT_B = "__checkpoint_B.json";
 var FORMAT_VERSION = 1;
+var CRC32_TABLE2 = (() => {
+  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 crc322(input) {
+  let crc = 4294967295;
+  for (let i = 0; i < input.length; i++) {
+    crc = CRC32_TABLE2[(crc ^ input.charCodeAt(i)) & 255] ^ crc >>> 8;
+  }
+  return (crc ^ 4294967295) >>> 0;
+}
 var CheckpointManager = class {
-  filePath;
+  baseDir;
   data;
   constructor(baseDir) {
-    this.filePath = path5.join(baseDir, CHECKPOINT_FILE);
+    this.baseDir = baseDir;
     this.data = {
       lsn: 0,
       walGen: 1,
@@ -997,47 +1071,66 @@ var CheckpointManager = class {
     this.load();
   }
   /* -------------------------
-     LOAD (Crash-safe)
+     LOAD (CRC + FALLBACK)
   ------------------------- */
   load() {
-    if (!fs5.existsSync(this.filePath)) {
+    const a = this.readCheckpoint(CHECKPOINT_A);
+    const b = this.readCheckpoint(CHECKPOINT_B);
+    if (a && b) {
+      this.data = a.data.lsn >= b.data.lsn ? a.data : b.data;
+      return;
+    }
+    if (a) {
+      this.data = a.data;
+      return;
+    }
+    if (b) {
+      this.data = b.data;
       return;
     }
+    console.warn("No valid checkpoint found, starting from zero");
+  }
+  readCheckpoint(file) {
+    const filePath = path5.join(this.baseDir, file);
+    if (!fs5.existsSync(filePath)) return null;
     try {
-      const raw = fs5.readFileSync(this.filePath, "utf8");
+      const raw = fs5.readFileSync(filePath, "utf8");
       const parsed = JSON.parse(raw);
-      if (typeof parsed.lsn === "number" && typeof parsed.walGen === "number") {
-        this.data = parsed;
+      if (!parsed?.data || typeof parsed.crc !== "number") {
+        return null;
+      }
+      const expected = crc322(JSON.stringify(parsed.data));
+      if (expected !== parsed.crc) {
+        console.error(`Checkpoint CRC mismatch: ${file}`);
+        return null;
       }
+      return parsed;
     } catch {
-      console.error("Checkpoint corrupted, starting from zero");
-      this.data = {
-        lsn: 0,
-        walGen: 1,
-        time: 0,
-        version: FORMAT_VERSION
-      };
+      return null;
     }
   }
   /* -------------------------
-     SAVE (Atomic Write)
+     SAVE (DUAL WRITE)
   ------------------------- */
   save(lsn, walGen) {
-    const newData = {
+    const data = {
       lsn,
       walGen,
       time: Date.now(),
       version: FORMAT_VERSION
     };
-    const tmpPath = this.filePath + TMP_SUFFIX2;
+    const stored = {
+      data,
+      crc: crc322(JSON.stringify(data))
+    };
+    const target = lsn % 2 === 0 ? CHECKPOINT_A : CHECKPOINT_B;
     try {
       fs5.writeFileSync(
-        tmpPath,
-        JSON.stringify(newData, null, 2),
-        { encoding: "utf8" }
+        path5.join(this.baseDir, target),
+        JSON.stringify(stored, null, 2),
+        "utf8"
       );
-      fs5.renameSync(tmpPath, this.filePath);
-      this.data = newData;
+      this.data = data;
     } catch (err) {
       console.error("Failed to write checkpoint:", err);
     }
@@ -1076,24 +1169,22 @@ var DBTransactionContext = class {
   }
   async commit() {
     for (const op of this.ops) {
-      const recordOp = {
+      await this.db.wal.append({
         tx: this.txId,
         type: "op",
         payload: op
-      };
-      await this.db.wal.append(recordOp);
+      });
     }
-    const commitRecord = {
+    const commitLSN = await this.db.wal.append({
       tx: this.txId,
       type: "commit"
-    };
-    await this.db.wal.append(commitRecord);
+    });
     await this.db.applyTransaction(this.ops);
-    const appliedRecord = {
+    const appliedLSN = await this.db.wal.append({
       tx: this.txId,
       type: "applied"
-    };
-    await this.db.wal.append(appliedRecord);
+    });
+    this.db.advanceCheckpoint(appliedLSN);
     await this.db.postCommitMaintenance();
   }
 };
@@ -1141,13 +1232,25 @@ var LioranDB = class _LioranDB {
         ops.get(record.tx).push(record.payload);
       }
     });
+    let highestAppliedLSN = fromLSN;
     for (const tx of committed) {
       if (applied.has(tx)) continue;
       const txOps = ops.get(tx);
       if (txOps) {
         await this.applyTransaction(txOps);
+        highestAppliedLSN = this.wal.getCurrentLSN();
       }
     }
+    this.advanceCheckpoint(highestAppliedLSN);
+  }
+  /* ------------------------- CHECKPOINT ADVANCE ------------------------- */
+  advanceCheckpoint(lsn) {
+    const current = this.checkpoint.get();
+    if (lsn > current.lsn) {
+      this.checkpoint.save(lsn, this.wal.getCurrentGen());
+      this.wal.cleanup(this.wal.getCurrentGen() - 1).catch(() => {
+      });
+    }
   }
   /* ------------------------- META ------------------------- */
   loadMeta() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@liorandb/core",
-  "version": "1.0.19",
+  "version": "1.1.0",
   "description": "LioranDB Core Module – Lightweight, local-first, peer-to-peer database management for Node.js.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/core/checkpoint.ts

@@ -9,27 +9,56 @@ export interface CheckpointData {
   lsn: number;        // Last durable LSN
   walGen: number;     // WAL generation at checkpoint
   time: number;       // Timestamp (ms)
-  version: number;    // For future format upgrades
+  version: number;    // Format version
+}
+
+interface StoredCheckpoint {
+  data: CheckpointData;
+  crc: number;
 }
 
 /* =========================
    CONSTANTS
 ========================= */
 
-const CHECKPOINT_FILE = "__checkpoint.json";
-const TMP_SUFFIX = ".tmp";
+const CHECKPOINT_A = "__checkpoint_A.json";
+const CHECKPOINT_B = "__checkpoint_B.json";
 const FORMAT_VERSION = 1;
 
+/* =========================
+   CRC32 (no deps)
+========================= */
+
+const 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) ? (0xEDB88320 ^ (c >>> 1)) : (c >>> 1);
+    }
+    table[i] = c >>> 0;
+  }
+  return table;
+})();
+
+function crc32(input: string): number {
+  let crc = 0xFFFFFFFF;
+  for (let i = 0; i < input.length; i++) {
+    crc = CRC32_TABLE[(crc ^ input.charCodeAt(i)) & 0xFF] ^ (crc >>> 8);
+  }
+  return (crc ^ 0xFFFFFFFF) >>> 0;
+}
+
 /* =========================
    CHECKPOINT MANAGER
 ========================= */
 
 export class CheckpointManager {
-  private filePath: string;
+  private baseDir: string;
   private data: CheckpointData;
 
   constructor(baseDir: string) {
-    this.filePath = path.join(baseDir, CHECKPOINT_FILE);
+    this.baseDir = baseDir;
     this.data = {
       lsn: 0,
       walGen: 1,
@@ -41,61 +70,84 @@ export class CheckpointManager {
   }
 
   /* -------------------------
-     LOAD (Crash-safe)
+     LOAD (CRC + FALLBACK)
   ------------------------- */
 
   private load() {
-    if (!fs.existsSync(this.filePath)) {
+    const a = this.readCheckpoint(CHECKPOINT_A);
+    const b = this.readCheckpoint(CHECKPOINT_B);
+
+    if (a && b) {
+      // pick newest valid checkpoint
+      this.data = a.data.lsn >= b.data.lsn ? a.data : b.data;
+      return;
+    }
+
+    if (a) {
+      this.data = a.data;
       return;
     }
 
+    if (b) {
+      this.data = b.data;
+      return;
+    }
+
+    console.warn("No valid checkpoint found, starting from zero");
+  }
+
+  private readCheckpoint(file: string): StoredCheckpoint | null {
+    const filePath = path.join(this.baseDir, file);
+    if (!fs.existsSync(filePath)) return null;
+
     try {
-      const raw = fs.readFileSync(this.filePath, "utf8");
-      const parsed = JSON.parse(raw) as CheckpointData;
-
-      if (
-        typeof parsed.lsn === "number" &&
-        typeof parsed.walGen === "number"
-      ) {
-        this.data = parsed;
+      const raw = fs.readFileSync(filePath, "utf8");
+      const parsed = JSON.parse(raw) as StoredCheckpoint;
+
+      if (!parsed?.data || typeof parsed.crc !== "number") {
+        return null;
       }
+
+      const expected = crc32(JSON.stringify(parsed.data));
+      if (expected !== parsed.crc) {
+        console.error(`Checkpoint CRC mismatch: ${file}`);
+        return null;
+      }
+
+      return parsed;
     } catch {
-      console.error("Checkpoint corrupted, starting from zero");
-      this.data = {
-        lsn: 0,
-        walGen: 1,
-        time: 0,
-        version: FORMAT_VERSION
-      };
+      return null;
     }
   }
 
   /* -------------------------
-     SAVE (Atomic Write)
+     SAVE (DUAL WRITE)
   ------------------------- */
 
   save(lsn: number, walGen: number) {
-    const newData: CheckpointData = {
+    const data: CheckpointData = {
       lsn,
       walGen,
       time: Date.now(),
       version: FORMAT_VERSION
     };
 
-    const tmpPath = this.filePath + TMP_SUFFIX;
+    const stored: StoredCheckpoint = {
+      data,
+      crc: crc32(JSON.stringify(data))
+    };
+
+    // alternate between A/B for crash safety
+    const target =
+      lsn % 2 === 0 ? CHECKPOINT_A : CHECKPOINT_B;
 
     try {
-      // Write to temp file first
       fs.writeFileSync(
-        tmpPath,
-        JSON.stringify(newData, null, 2),
-        { encoding: "utf8" }
+        path.join(this.baseDir, target),
+        JSON.stringify(stored, null, 2),
+        "utf8"
       );
-
-      // Atomic rename
-      fs.renameSync(tmpPath, this.filePath);
-
-      this.data = newData;
+      this.data = data;
     } catch (err) {
       console.error("Failed to write checkpoint:", err);
     }

package/src/core/compaction.ts

@@ -18,42 +18,40 @@ const INDEX_DIR = "__indexes";
 --------------------------------------------------------- */
 
 /**
- * Full safe compaction pipeline:
+ * Full production-safe compaction:
  * 1. Crash recovery
  * 2. Snapshot rebuild
- * 3. Atomic directory swap
- * 4. Index rebuild
+ * 3. Atomic swap
+ * 4. Reopen DB
+ * 5. Rebuild indexes
  */
 export async function compactCollectionEngine(col: Collection) {
   const baseDir = col.dir;
   const tmpDir = baseDir + TMP_SUFFIX;
   const oldDir = baseDir + OLD_SUFFIX;
 
-  // Recover from any previous crash mid-compaction
   await crashRecovery(baseDir);
 
-  // Clean leftovers (paranoia safety)
   safeRemove(tmpDir);
   safeRemove(oldDir);
 
-  // Step 1: rebuild snapshot
   await snapshotRebuild(col, tmpDir);
 
-  // Step 2: atomic swap
-  atomicSwap(baseDir, tmpDir, oldDir);
+  await atomicSwap(baseDir, tmpDir, oldDir);
 
-  // Cleanup
   safeRemove(oldDir);
+
+  // Reopen DB after swap
+  await reopenCollectionDB(col);
+
+  // Rebuild indexes after compaction
+  await rebuildIndexes(col);
 }
 
 /* ---------------------------------------------------------
    SNAPSHOT REBUILD
 --------------------------------------------------------- */
 
-/**
- * Rebuilds DB by copying only live keys
- * WAL is assumed already checkpointed
- */
 async function snapshotRebuild(col: Collection, tmpDir: string) {
   fs.mkdirSync(tmpDir, { recursive: true });
 
@@ -68,28 +66,33 @@ async function snapshotRebuild(col: Collection, tmpDir: string) {
   }
 
   await tmpDB.close();
-  await col.db.close();
+  await col.db.close(); // important: close before swap
 }
 
 /* ---------------------------------------------------------
-   ATOMIC SWAP
+   ATOMIC SWAP (HARDENED)
 --------------------------------------------------------- */
 
-/**
- * Atomic directory replacement (POSIX safe)
- */
-function atomicSwap(base: string, tmp: string, old: string) {
+async function atomicSwap(base: string, tmp: string, old: string) {
+  // Phase 1: rename base → old
   fs.renameSync(base, old);
-  fs.renameSync(tmp, base);
+
+  try {
+    // Phase 2: rename tmp → base
+    fs.renameSync(tmp, base);
+  } catch (err) {
+    // Rollback if tmp rename fails
+    if (fs.existsSync(old)) {
+      fs.renameSync(old, base);
+    }
+    throw err;
+  }
 }
 
 /* ---------------------------------------------------------
    CRASH RECOVERY
 --------------------------------------------------------- */
 
-/**
- * Handles all partial-compaction states
- */
 export async function crashRecovery(baseDir: string) {
   const tmp = baseDir + TMP_SUFFIX;
   const old = baseDir + OLD_SUFFIX;
@@ -106,7 +109,7 @@ export async function crashRecovery(baseDir: string) {
     return;
   }
 
-  // Case 2: rename(base → old) happened, but tmp missing
+  // Case 2: base→old happened but tmp missing
   if (!baseExists && oldExists) {
     fs.renameSync(old, baseDir);
     return;
@@ -119,44 +122,56 @@ export async function crashRecovery(baseDir: string) {
 }
 
 /* ---------------------------------------------------------
-   INDEX REBUILD
+   REOPEN DB
+--------------------------------------------------------- */
+
+async function reopenCollectionDB(col: Collection) {
+  col.db = new ClassicLevel(col.dir, {
+    valueEncoding: "utf8"
+  });
+}
+
+/* ---------------------------------------------------------
+   INDEX REBUILD (SAFE)
 --------------------------------------------------------- */
 
-/**
- * Rebuilds all indexes from compacted DB
- * Guarantees index consistency
- */
 export async function rebuildIndexes(col: Collection) {
   const indexRoot = path.join(col.dir, INDEX_DIR);
 
-  // Close existing index handles
-  for (const idx of col["indexes"].values()) {
+  const oldIndexes = new Map(col["indexes"]);
+
+  // Close old index handles
+  for (const idx of oldIndexes.values()) {
     try {
       await idx.close();
     } catch {}
   }
 
-  // Destroy index directory
   safeRemove(indexRoot);
   fs.mkdirSync(indexRoot, { recursive: true });
 
-  const newIndexes = new Map<string, Index>();
+  const rebuiltIndexes = new Map<string, Index>();
 
-  for (const idx of col["indexes"].values()) {
+  for (const idx of oldIndexes.values()) {
     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 rebuilt.insert(doc);
+
+      try {
+        const doc = decryptData(enc);
+        await rebuilt.insert(doc);
+      } catch {
+        // Skip corrupted doc safely
+      }
     }
 
-    newIndexes.set(idx.field, rebuilt);
+    rebuiltIndexes.set(idx.field, rebuilt);
   }
 
-  col["indexes"] = newIndexes;
+  col["indexes"] = rebuiltIndexes;
 }
 
 /* ---------------------------------------------------------

package/src/core/database.ts

@@ -13,9 +13,6 @@ import { CheckpointManager } from "./checkpoint.js";
 /* ----------------------------- TYPES ----------------------------- */
 
 type TXOp = { tx: number; col: string; op: string; args: any[] };
-type TXCommit = { tx: number; commit: true };
-type TXApplied = { tx: number; applied: true };
-type WALEntry = TXOp | TXCommit | TXApplied;
 
 type IndexMeta = {
   field: string;
@@ -58,28 +55,32 @@ class DBTransactionContext {
   }
 
   async commit() {
+    // 1️⃣ Write all operations
     for (const op of this.ops) {
-      const recordOp: any = {
+      await this.db.wal.append({
         tx: this.txId,
         type: "op",
         payload: op
-      };
-      await this.db.wal.append(recordOp);
+      } as any);
     }
 
-    const commitRecord: any = {
+    // 2️⃣ Commit marker
+    const commitLSN = await this.db.wal.append({
       tx: this.txId,
       type: "commit"
-    };
-    await this.db.wal.append(commitRecord);
+    } as any);
 
+    // 3️⃣ Apply to storage
     await this.db.applyTransaction(this.ops);
 
-    const appliedRecord: any = {
+    // 4️⃣ Applied marker
+    const appliedLSN = await this.db.wal.append({
       tx: this.txId,
       type: "applied"
-    };
-    await this.db.wal.append(appliedRecord);
+    } as any);
+
+    // 5️⃣ Advance checkpoint to durable applied LSN
+    this.db.advanceCheckpoint(appliedLSN);
 
     await this.db.postCommitMaintenance();
   }
@@ -143,18 +144,37 @@ export class LioranDB {
         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);
+        ops.get(record.tx)!.push(record.payload as TXOp);
       }
     });
 
+    let highestAppliedLSN = fromLSN;
+
     for (const tx of committed) {
       if (applied.has(tx)) continue;
 
       const txOps = ops.get(tx);
       if (txOps) {
         await this.applyTransaction(txOps);
+        highestAppliedLSN = this.wal.getCurrentLSN();
       }
     }
+
+    // Advance checkpoint after recovery
+    this.advanceCheckpoint(highestAppliedLSN);
+  }
+
+  /* ------------------------- CHECKPOINT ADVANCE ------------------------- */
+
+  public advanceCheckpoint(lsn: number) {
+    const current = this.checkpoint.get();
+
+    if (lsn > current.lsn) {
+      this.checkpoint.save(lsn, this.wal.getCurrentGen());
+
+      // Optional WAL cleanup (safe because checkpoint advanced)
+      this.wal.cleanup(this.wal.getCurrentGen() - 1).catch(() => {});
+    }
   }
 
   /* ------------------------- META ------------------------- */
@@ -307,7 +327,7 @@ export class LioranDB {
   /* ------------------------- POST COMMIT ------------------------- */
 
   public async postCommitMaintenance() {
-    // Custom maintenance can be added here
+    // Hook for background compaction, stats, etc.
   }
 
   /* ------------------------- SHUTDOWN ------------------------- */

package/src/core/wal.ts

@@ -16,12 +16,11 @@ type StoredRecord = WALRecord & { crc: number };
    CONSTANTS
 ========================= */
 
-const MAX_WAL_SIZE = 16 * 1024 * 1024; // 16 MB
+const MAX_WAL_SIZE = 16 * 1024 * 1024; // 16MB
 const WAL_DIR = "__wal";
 
 /* =========================
-   CRC32 IMPLEMENTATION
-   (no dependencies)
+   CRC32 (no deps)
 ========================= */
 
 const CRC32_TABLE = (() => {
@@ -37,12 +36,11 @@ const CRC32_TABLE = (() => {
 })();
 
 function crc32(input: string): number {
-  let crc = 0xFFFFFFFF;
+  let crc = 0xffffffff;
   for (let i = 0; i < input.length; i++) {
-    const byte = input.charCodeAt(i);
-    crc = CRC32_TABLE[(crc ^ byte) & 0xFF] ^ (crc >>> 8);
+    crc = CRC32_TABLE[(crc ^ input.charCodeAt(i)) & 0xff] ^ (crc >>> 8);
   }
-  return (crc ^ 0xFFFFFFFF) >>> 0;
+  return (crc ^ 0xffffffff) >>> 0;
 }
 
 /* =========================
@@ -58,7 +56,9 @@ export class WALManager {
   constructor(baseDir: string) {
     this.walDir = path.join(baseDir, WAL_DIR);
     fs.mkdirSync(this.walDir, { recursive: true });
+
     this.currentGen = this.detectLastGeneration();
+    this.recoverLSNFromExistingLogs();
   }
 
   /* -------------------------
@@ -80,12 +80,52 @@ export class WALManager {
 
     for (const f of files) {
       const m = f.match(/^wal-(\d+)\.log$/);
-      if (m) max = Math.max(max, Number(m[1]));
+      if (m) {
+        const gen = Number(m[1]);
+        if (!Number.isNaN(gen)) {
+          max = Math.max(max, gen);
+        }
+      }
     }
 
     return max || 1;
   }
 
+  private recoverLSNFromExistingLogs() {
+    const files = this.getSortedWalFiles();
+
+    for (const file of files) {
+      const filePath = path.join(this.walDir, file);
+      const lines = fs.readFileSync(filePath, "utf8").split("\n");
+
+      for (const line of lines) {
+        if (!line.trim()) continue;
+
+        try {
+          const parsed: StoredRecord = JSON.parse(line);
+          const { crc, ...record } = parsed;
+
+          if (crc32(JSON.stringify(record)) !== crc) break;
+
+          this.lsn = Math.max(this.lsn, record.lsn);
+        } catch {
+          break; // stop on corruption
+        }
+      }
+    }
+  }
+
+  private getSortedWalFiles(): string[] {
+    return fs
+      .readdirSync(this.walDir)
+      .filter(f => /^wal-\d+\.log$/.test(f))
+      .sort((a, b) => {
+        const ga = Number(a.match(/^wal-(\d+)\.log$/)![1]);
+        const gb = Number(b.match(/^wal-(\d+)\.log$/)![1]);
+        return ga - gb;
+      });
+  }
+
   private async open() {
     if (!this.fd) {
       this.fd = await fs.promises.open(this.walPath(), "a");
@@ -94,6 +134,7 @@ export class WALManager {
 
   private async rotate() {
     if (this.fd) {
+      await this.fd.sync();
       await this.fd.close();
       this.fd = null;
     }
@@ -101,7 +142,7 @@ export class WALManager {
   }
 
   /* -------------------------
-     APPEND
+     APPEND (Crash-safe)
   ------------------------- */
 
   async append(record: Omit<WALRecord, "lsn">): Promise<number> {
@@ -113,12 +154,15 @@ export class WALManager {
     };
 
     const body = JSON.stringify(full);
+
     const stored: StoredRecord = {
       ...full,
       crc: crc32(body)
     };
 
-    await this.fd!.write(JSON.stringify(stored) + "\n");
+    const line = JSON.stringify(stored) + "\n";
+
+    await this.fd!.write(line);
     await this.fd!.sync();
 
     const stat = await this.fd!.stat();
@@ -130,7 +174,7 @@ export class WALManager {
   }
 
   /* -------------------------
-     REPLAY
+     REPLAY (Auto-heal tail)
   ------------------------- */
 
   async replay(
@@ -139,44 +183,54 @@ export class WALManager {
   ): Promise<void> {
     if (!fs.existsSync(this.walDir)) return;
 
-    const files = fs
-      .readdirSync(this.walDir)
-      .filter(f => f.startsWith("wal-"))
-      .sort();
+    const files = this.getSortedWalFiles();
 
     for (const file of files) {
       const filePath = path.join(this.walDir, file);
-      const data = fs.readFileSync(filePath, "utf8");
-      const lines = data.split("\n");
+
+      const fd = fs.openSync(filePath, "r+");
+      const content = fs.readFileSync(filePath, "utf8");
+      const lines = content.split("\n");
+
+      let validOffset = 0;
 
       for (let i = 0; i < lines.length; i++) {
         const line = lines[i];
-        if (!line.trim()) continue;
+        if (!line.trim()) {
+          validOffset += line.length + 1;
+          continue;
+        }
 
         let parsed: StoredRecord;
+
         try {
           parsed = JSON.parse(line);
         } catch {
-          console.error("WAL parse error, stopping replay");
-          return;
+          break;
         }
 
         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;
+          break;
         }
 
+        validOffset += line.length + 1;
+
         if (record.lsn <= fromLSN) continue;
 
         this.lsn = Math.max(this.lsn, record.lsn);
         await apply(record);
       }
+
+      // Truncate corrupted tail (auto-heal)
+      const stat = fs.fstatSync(fd);
+      if (validOffset < stat.size) {
+        fs.ftruncateSync(fd, validOffset);
+      }
+
+      fs.closeSync(fd);
     }
   }
 
@@ -188,6 +242,7 @@ export class WALManager {
     if (!fs.existsSync(this.walDir)) return;
 
     const files = fs.readdirSync(this.walDir);
+
     for (const f of files) {
       const m = f.match(/^wal-(\d+)\.log$/);
       if (!m) continue;