mumpix 1.0.19 → 1.0.29

package/src/core/store.js

@@ -1,64 +1,61 @@
-'use strict';
-
-/**
- * MumpixStore — crash-safe, append-only storage engine
- *
- * File format (.mumpix):
- *   Line 0: JSON header  {"v":1,"consistency":"strict","created":ts}
- *   Line N: JSON record  {"id":1,"content":"...","ts":ts,"h":"0xabc"}
- *
- * WAL (.mumpix.wal):
- *   Each line: {"op":"write"|"clear","entry"?:{...},"ts":ts}
- *   Replayed on open if present, then merged and deleted.
- */
-
-const fs   = require('fs');
-const path = require('path');
-const os   = require('os');
-const crypto = require('crypto');
-
-const MAGIC_VERSION = 1;
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+const crypto = require("crypto");
+const { WalWriter } = require("./wal-writer");
+const { InvertedIndex } = require("./inverted-index");
+const { tokenize } = require("./recall");
+
+function normalizeMeta(meta) {
+  if (!meta || typeof meta !== "object") return {};
+  const out = {};
+  if (Number.isFinite(meta.ts)) out.ts = Number(meta.ts);
+  if (typeof meta.workspace === "string" && meta.workspace.trim()) {
+    out.workspace = meta.workspace.trim();
+  }
+  if (typeof meta.repo === "string" && meta.repo.trim()) {
+    out.repo = meta.repo.trim();
+  }
+  if (typeof meta.source === "string" && meta.source.trim()) {
+    out.source = meta.source.trim();
+  }
+  return out;
+}
 
 class MumpixStore {
   constructor(filePath) {
     this.filePath = path.resolve(filePath);
-    this.walPath  = this.filePath + '.wal';
-    this.lockPath = this.filePath + '.lock';
-    this.header   = null;
-    this.records  = [];       // { id, content, ts, h }
-    this._nextId  = 1;
-    this._fd      = null;     // open file descriptor for appends
-    this._lockFd  = null;     // lock file descriptor
+    this.walPath = `${this.filePath}.wal`;
+    this.lockPath = `${this.filePath}.lock`;
+    this.header = null;
+    this.records = [];
+    this._nextId = 1;
+    this._fd = null;
+    this._lockFd = null;
     this._strictIntegrity = false;
-    this._mlDsa   = null;     // ML-DSA-65 engine for Verified mode
-    this._signingKey = null;  // Private key for signing (Verified mode)
-    this._publicKey  = null;  // Public key for verification (Verified mode)
+    this._walWriter = null;
+    this._index = null;
+    this._recallIndexEnabled = true;
   }
 
-  // ── Public ──────────────────────────────────────
-
-  async open(opts = {}) {
-    const consistency = opts.consistency || 'eventual';
-    this._strictIntegrity = consistency === 'strict' || consistency === 'verified';
+  open(opts = {}) {
+    const consistency = opts.consistency || "eventual";
+    this._strictIntegrity = consistency === "strict" || consistency === "verified";
+    this._recallIndexEnabled = opts.recallIndex !== false;
     this._acquireLock(opts);
-    
-    if (consistency === 'verified') {
-      await this._initQuantumEngine();
-    }
 
     if (fs.existsSync(this.filePath)) {
       try {
         this._load();
       } catch (err) {
-        const recovered = this._canRecoverFromIntegrityError(err) && this._recoverFromTailCorruption();
-        if (!recovered) {
+        if (!(this._canRecoverFromIntegrityError(err) && this._recoverFromTailCorruption())) {
           this._releaseLock();
           throw err;
         }
         this._load();
       }
 
-      // Replay any uncommitted WAL
       try {
         this._replayWAL();
       } catch (err) {
@@ -67,212 +64,267 @@ class MumpixStore {
       }
     } else {
       this.header = {
-        v: MAGIC_VERSION,
+        v: 1,
         consistency,
         created: Date.now(),
         path: path.basename(this.filePath),
-        fileId: crypto.randomUUID ? crypto.randomUUID() : crypto.randomBytes(16).toString('hex'),
-        hashAlg: 'hmac-sha256',
+        fileId: crypto.randomUUID ? crypto.randomUUID() : crypto.randomBytes(16).toString("hex"),
+        hashAlg: "hmac-sha256",
       };
       this._writeHeader();
     }
 
     if (!this.header.fileId) {
-      this.header.fileId = crypto.randomUUID ? crypto.randomUUID() : crypto.randomBytes(16).toString('hex');
+      this.header.fileId = crypto.randomUUID
+        ? crypto.randomUUID()
+        : crypto.randomBytes(16).toString("hex");
       this._rewriteFull();
     }
     if (!this.header.hashAlg) {
-      this.header.hashAlg = 'hmac-sha256';
+      this.header.hashAlg = "hmac-sha256";
       this._rewriteFull();
     }
-
-    // Update consistency if caller changed it
     if (this.header.consistency !== consistency) {
       this.header.consistency = consistency;
       this._rewriteFull();
     }
 
-    // Open append FD
+    this._walWriter = new WalWriter(this.walPath, consistency, {
+      intervalMs: Number.isFinite(opts.walFlushIntervalMs) ? opts.walFlushIntervalMs : undefined,
+      maxPendingBytes: Number.isFinite(opts.walMaxPendingBytes) ? opts.walMaxPendingBytes : undefined,
+    });
+
     try {
-      this._fd = fs.openSync(this.filePath, 'a');
+      this._fd = fs.openSync(this.filePath, "a");
     } catch (err) {
       this._releaseLock();
       throw err;
     }
+
+    this._initIndex();
     return this;
   }
 
   close() {
+    if (this._index) {
+      try {
+        this._index.persist();
+      } catch (_) {}
+    }
+    if (this._walWriter) {
+      this._walWriter.close({ flush: true });
+      this._walWriter = null;
+    }
     if (this._fd !== null) {
       fs.closeSync(this._fd);
       this._fd = null;
     }
     this._releaseLock();
-    // Zero out sensitive key material in memory
-    if (this._signingKey) this._signingKey.fill(0);
-    this._signingKey = null;
   }
 
-  /**
-   * Append a record. WAL-first for crash safety.
-   * Returns the new record.
-   */
+  flush() {
+    if (this._walWriter) this._walWriter.flush();
+    if (this._fd !== null) fs.fdatasyncSync(this._fd);
+    if (this._index) this._index.persist();
+  }
+
   write(content, meta = {}) {
-    const trimmed = content.trim();
-    const sanitizedMeta = sanitizeMeta(meta);
-    const prevH = this.records.length > 0 ? this.records[this.records.length - 1].h : '0';
-    
-    const record = {
-      id:      this._nextId++,
-      content: trimmed,
-      ts:      Number.isFinite(sanitizedMeta.ts) ? Number(sanitizedMeta.ts) : Date.now(),
-      h:       this._hash(trimmed, prevH, this._nextId - 1),
-      ...(sanitizedMeta.workspace ? { workspace: sanitizedMeta.workspace } : {}),
-      ...(sanitizedMeta.repo ? { repo: sanitizedMeta.repo } : {}),
-      ...(sanitizedMeta.source ? { source: sanitizedMeta.source } : {}),
-    };
+    const text = String(content).trim();
+    const cleanMeta = normalizeMeta(meta);
+    const record = this._buildRecord(text, cleanMeta);
+
+    this._appendWal({ op: "write", entry: record, ts: Date.now() });
 
-    // If Verified mode and engine/keys are ready, sign the hash chain link
-    if (this._mlDsa && this._signingKey) {
-      const msg = Buffer.from(record.h, 'utf8');
-      const sig = this._mlDsa.sign(msg, this._signingKey);
-      record.sig = Buffer.from(sig).toString('hex');
+    try {
+      fs.writeSync(this._fd, `${JSON.stringify(record)}\n`, null, "utf8");
+      if (this._requiresPerRecordSync()) fs.fdatasyncSync(this._fd);
+    } catch (err) {
+      throw err;
     }
 
-    // 1. Write to WAL and force it to disk before touching main file.
-    this._appendWal({ op: 'write', entry: record, ts: Date.now() });
+    this._clearWAL();
+    this.records.push(record);
+    if (this._index) this._index.add(record);
+    return record;
+  }
 
-    // 2. Commit to main file
-    try {
-      const line = JSON.stringify(record) + '\n';
-      fs.writeSync(this._fd, line, null, 'utf8');
+  writeBatch(items) {
+    if (!Array.isArray(items) || !items.length) return [];
 
-      // 3. Sync to disk (strict/verified modes flush immediately)
-      const consistency = this.header.consistency;
-      if (consistency === 'strict' || consistency === 'verified') {
-        fs.fdatasyncSync(this._fd);
+    const records = items.map((item) => {
+      if (item && typeof item === "object" && !Array.isArray(item)) {
+        return this._buildRecord(String(item.content || "").trim(), normalizeMeta(item));
       }
+      return this._buildRecord(String(item || "").trim(), {});
+    });
+
+    const walLines = records.map((record) =>
+      JSON.stringify({ op: "write", entry: record, ts: Date.now() })
+    );
+
+    if (this._walWriter) {
+      this._walWriter.appendBatch(walLines);
+    } else {
+      for (const line of walLines) this._appendWal(JSON.parse(line));
+    }
+
+    try {
+      fs.writeSync(
+        this._fd,
+        records.map((record) => JSON.stringify(record)).join("\n") + "\n",
+        null,
+        "utf8"
+      );
+      if (this._requiresPerRecordSync()) fs.fdatasyncSync(this._fd);
     } catch (err) {
-      // WAL remains present; write will be replayed on next open.
       throw err;
     }
 
-    // 4. Remove WAL entry (write succeeded)
     this._clearWAL();
-
-    this.records.push(record);
-    return record;
+    for (const record of records) {
+      this.records.push(record);
+      if (this._index) this._index.add(record);
+    }
+    return records;
   }
 
-  /**
-   * Clear all records — WAL-first.
-   */
   clear() {
     const count = this.records.length;
-
-    this._appendWal({ op: 'clear', count, ts: Date.now() });
-
+    this._appendWal({ op: "clear", count, ts: Date.now() });
     this.records = [];
     this._nextId = 1;
+    if (this._index) this._index.reset();
     this._rewriteFull();
     this._clearWAL();
-
+    if (this._index) this._index.persist();
     return count;
   }
 
-  /**
-   * Return all records (immutable copy).
-   */
   all() {
-    return this.records.map(r => ({ ...r }));
+    return this.records.map((record) => ({ ...record }));
   }
 
-  /**
-   * Return store metadata.
-   */
   stats() {
     const stat = fs.existsSync(this.filePath) ? fs.statSync(this.filePath) : null;
     return {
-      path:        this.filePath,
+      path: this.filePath,
       consistency: this.header.consistency,
-      records:     this.records.length,
-      created:     this.header.created,
-      sizeBytes:   stat ? stat.size : 0,
-      version:     this.header.v,
+      records: this.records.length,
+      created: this.header.created,
+      sizeBytes: stat ? stat.size : 0,
+      version: this.header.v,
+      index: this.indexStats(),
     };
   }
 
-  async _initQuantumEngine() {
-    const mlDsaPath = 'file://' + path.resolve(__dirname, 'ml-dsa.mjs');
-    const { ml_dsa65 } = await import(mlDsaPath);
-    this._mlDsa = ml_dsa65;
+  indexedCandidates(query, cap = 400) {
+    if (!this._index) return null;
+    return this._index.candidates(query, cap);
+  }
 
-    const keyPath = this.filePath + '.key';
-    if (fs.existsSync(keyPath)) {
-      // Load existing key
-      const keys = JSON.parse(fs.readFileSync(keyPath, 'utf8'));
-      this._signingKey = Buffer.from(keys.sk, 'hex');
-      this._publicKey  = Buffer.from(keys.pk, 'hex');
-    } else {
-      // Generate fresh ML-DSA-65 keypair for this database
-      console.log(`[Quantum] Generating fresh Level 3 keypair for ${path.basename(this.filePath)}...`);
-      const { publicKey, secretKey } = this._mlDsa.keygen();
-      this._signingKey = secretKey;
-      this._publicKey  = publicKey;
-      
-      // Persist locally
-      fs.writeFileSync(keyPath, JSON.stringify({
-        pk: Buffer.from(publicKey).toString('hex'),
-        sk: Buffer.from(secretKey).toString('hex')
-      }), 'utf8');
-      
-      if (this.header) {
-        this.header.pk = Buffer.from(publicKey).toString('hex');
-        this._rewriteFull();
+  rebuildIndex() {
+    if (!this._recallIndexEnabled) return null;
+    this._index = new InvertedIndex(tokenize, this._indexPath());
+    for (const record of this.records) this._index.add(record);
+    this._index.persist();
+    return this.indexStats();
+  }
+
+  indexStats() {
+    if (!this._index) {
+      return {
+        enabled: false,
+        terms: 0,
+        docCount: 0,
+        highWaterSeq: 0,
+        sidecarPath: this._indexPath(),
+        sizeBytes: 0,
+      };
+    }
+    return { enabled: true, ...this._index.stats() };
+  }
+
+  _buildRecord(text, meta) {
+    const record = {
+      id: this._nextId++,
+      content: text,
+      ts: Number.isFinite(meta.ts) ? Number(meta.ts) : Date.now(),
+      h: this._hash(text),
+    };
+    if (meta.workspace) record.workspace = meta.workspace;
+    if (meta.repo) record.repo = meta.repo;
+    if (meta.source) record.source = meta.source;
+    return record;
+  }
+
+  _requiresPerRecordSync() {
+    return this.header.consistency === "strict" || this.header.consistency === "verified";
+  }
+
+  _initIndex() {
+    if (!this._recallIndexEnabled) {
+      this._index = null;
+      return;
+    }
+
+    this._index = new InvertedIndex(tokenize, this._indexPath());
+    const highWater = this._index.loadSidecar();
+    if (highWater > 0) {
+      this._index.hydrate(this.records.filter((record) => record.id <= highWater));
+      for (const record of this.records) {
+        if (record.id > highWater) this._index.add(record);
       }
+    } else {
+      for (const record of this.records) this._index.add(record);
     }
   }
 
-  // ── Private ─────────────────────────────────────
+  _indexPath() {
+    return `${this.filePath}.idx`;
+  }
 
   _load() {
-    const raw  = fs.readFileSync(this.filePath, 'utf8');
-    const lines = raw.split('\n').filter(l => l.trim());
-
+    const lines = fs
+      .readFileSync(this.filePath, "utf8")
+      .split("\n")
+      .filter((line) => line.trim());
     if (!lines.length) throw new Error(`mumpix: corrupt or empty file: ${this.filePath}`);
 
     this.header = JSON.parse(lines[0]);
-    if (this.header.v !== MAGIC_VERSION) {
-      throw new Error(`mumpix: unsupported file version ${this.header.v}`);
-    }
+    if (this.header.v !== 1) throw new Error(`mumpix: unsupported file version ${this.header.v}`);
 
     this.records = [];
+    this._nextId = 1;
     let lastId = 0;
-    let prevH = '0';
-    const seenIds = new Set();
+    const seen = new Set();
+
     for (let i = 1; i < lines.length; i++) {
       try {
-        const r = JSON.parse(lines[i]);
-        if (r && Number.isInteger(r.id) && typeof r.content === 'string' && r.content.length > 0) {
-          const monotonic = r.id > lastId;
-          const duplicate = seenIds.has(r.id);
-          const hashOk = this._verifyHash(r, prevH);
-          if (!monotonic || duplicate || !hashOk) {
-            const msg = !hashOk
-              ? `mumpix: integrity hash mismatch for id=${r.id}`
-              : `mumpix: invalid record order/id at id=${r.id}`;
-            if (this._strictIntegrity) throw new Error(msg);
+        const record = JSON.parse(lines[i]);
+        if (
+          record &&
+          Number.isInteger(record.id) &&
+          typeof record.content === "string" &&
+          record.content.length > 0
+        ) {
+          const ordered = record.id > lastId;
+          const duplicate = seen.has(record.id);
+          const validHash = this._verifyHash(record);
+          if (!ordered || duplicate || !validHash) {
+            const message = validHash
+              ? `mumpix: invalid record order/id at id=${record.id}`
+              : `mumpix: integrity hash mismatch for id=${record.id}`;
+            if (this._strictIntegrity) throw new Error(message);
             continue;
           }
-          this.records.push(r);
-          prevH = r.h;
-          seenIds.add(r.id);
-          lastId = r.id;
-          if (r.id >= this._nextId) this._nextId = r.id + 1;
+
+          this.records.push(record);
+          seen.add(record.id);
+          lastId = record.id;
+          if (record.id >= this._nextId) this._nextId = record.id + 1;
         }
       } catch (err) {
         if (this._strictIntegrity) throw err;
-        // skip corrupt lines in eventual mode
       }
     }
   }
@@ -280,80 +332,92 @@ class MumpixStore {
   _replayWAL() {
     if (!fs.existsSync(this.walPath)) return;
 
-    const raw   = fs.readFileSync(this.walPath, 'utf8');
-    const lines = raw.split('\n').filter(l => l.trim());
-    let dirty   = false;
+    const lines = fs
+      .readFileSync(this.walPath, "utf8")
+      .split("\n")
+      .filter((line) => line.trim());
+    let changed = false;
     let lastId = this.records.length ? this.records[this.records.length - 1].id : 0;
-    const seenIds = new Set(this.records.map(r => r.id));
+    const seen = new Set(this.records.map((record) => record.id));
 
     for (const line of lines) {
       try {
-        const entry = JSON.parse(line);
-        if (entry.op === 'write' && entry.entry) {
-          const candidate = entry.entry;
-          const exists = seenIds.has(candidate.id);
-          const monotonic = Number.isInteger(candidate.id) && candidate.id > lastId;
-          const hashOk = this._verifyHash(candidate, prevH);
-          if (!exists && monotonic && hashOk) {
-            this.records.push(entry.entry);
-            if (entry.entry.id >= this._nextId) this._nextId = entry.entry.id + 1;
-            seenIds.add(entry.entry.id);
-            prevH = entry.entry.h;
-            lastId = entry.entry.id;
-            dirty = true;
+        const event = JSON.parse(line);
+        if (event.op === "write" && event.entry) {
+          const record = event.entry;
+          const duplicate = seen.has(record.id);
+          const ordered = Number.isInteger(record.id) && record.id > lastId;
+          const validHash = this._verifyHash(record);
+          if (!duplicate && ordered && validHash) {
+            this.records.push(record);
+            if (record.id >= this._nextId) this._nextId = record.id + 1;
+            seen.add(record.id);
+            lastId = record.id;
+            changed = true;
           } else if (this._strictIntegrity) {
-            throw new Error(`mumpix: rejected WAL write id=${candidate.id}`);
+            throw new Error(`mumpix: rejected WAL write id=${record.id}`);
           }
-        } else if (entry.op === 'clear') {
+        } else if (event.op === "clear") {
           this.records = [];
           this._nextId = 1;
-          seenIds.clear();
-          prevH = '0';
+          seen.clear();
           lastId = 0;
-          dirty = true;
+          changed = true;
         }
       } catch (err) {
         if (this._strictIntegrity) throw err;
-        // skip corrupt WAL lines in eventual mode
       }
     }
 
-    if (dirty) this._rewriteFull();
+    if (changed) this._rewriteFull();
     this._clearWAL();
   }
 
   _writeHeader() {
     const dir = path.dirname(this.filePath);
     if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
-    fs.writeFileSync(this.filePath, JSON.stringify(this.header) + '\n', 'utf8');
+    fs.writeFileSync(this.filePath, `${JSON.stringify(this.header)}\n`, "utf8");
   }
 
   _rewriteFull() {
-    // Atomic rewrite via temp file
-    const tmp = this.filePath + '.tmp.' + process.pid;
+    if (this._walWriter) {
+      try {
+        this._walWriter.flush();
+      } catch (_) {}
+    }
+
+    const tmp = `${this.filePath}.tmp.${process.pid}`;
     const lines = [JSON.stringify(this.header)];
-    for (const r of this.records) lines.push(JSON.stringify(r));
-    fs.writeFileSync(tmp, lines.join('\n') + '\n', 'utf8');
+    for (const record of this.records) lines.push(JSON.stringify(record));
+    fs.writeFileSync(tmp, `${lines.join("\n")}\n`, "utf8");
     fs.renameSync(tmp, this.filePath);
 
-    // Re-open append FD if needed
     if (this._fd !== null) {
       fs.closeSync(this._fd);
-      this._fd = fs.openSync(this.filePath, 'a');
+      this._fd = fs.openSync(this.filePath, "a");
     }
   }
 
   _clearWAL() {
-    if (fs.existsSync(this.walPath)) {
-      fs.unlinkSync(this.walPath);
+    if (this._walWriter) {
+      this._walWriter.unlink({ flush: this._requiresPerRecordSync() });
+    } else {
+      try {
+        fs.unlinkSync(this.walPath);
+      } catch (_) {}
     }
   }
 
-  _appendWal(entry) {
-    const line = JSON.stringify(entry) + '\n';
-    const fd = fs.openSync(this.walPath, 'a');
+  _appendWal(event) {
+    const line = JSON.stringify(event);
+    if (this._walWriter) {
+      this._walWriter.append(line);
+      return;
+    }
+
+    const fd = fs.openSync(this.walPath, "a");
     try {
-      fs.writeSync(fd, line, null, 'utf8');
+      fs.writeSync(fd, `${line}\n`, null, "utf8");
       fs.fdatasyncSync(fd);
     } finally {
       fs.closeSync(fd);
@@ -362,54 +426,62 @@ class MumpixStore {
 
   _acquireLock(opts = {}) {
     if (opts.lock === false) return;
-    const staleMs = Number.isFinite(opts.lockStaleMs) ? Number(opts.lockStaleMs) : 5 * 60 * 1000;
+    const staleMs = Number.isFinite(opts.lockStaleMs) ? Number(opts.lockStaleMs) : 300000;
     const payload = JSON.stringify({ pid: process.pid, ts: Date.now() });
 
     for (let attempt = 0; attempt < 2; attempt++) {
       try {
-        this._lockFd = fs.openSync(this.lockPath, 'wx');
-        fs.writeSync(this._lockFd, payload, null, 'utf8');
+        this._lockFd = fs.openSync(this.lockPath, "wx");
+        fs.writeSync(this._lockFd, payload, null, "utf8");
         fs.fdatasyncSync(this._lockFd);
         return;
       } catch (err) {
-        if (!err || err.code !== 'EEXIST') throw err;
+        if (!err || err.code !== "EEXIST") throw err;
         try {
-          const st = fs.statSync(this.lockPath);
-          if (Date.now() - st.mtimeMs > staleMs) {
+          const stat = fs.statSync(this.lockPath);
+          if (Date.now() - stat.mtimeMs > staleMs) {
             fs.unlinkSync(this.lockPath);
             continue;
           }
         } catch (_) {
-          // lock disappeared between checks; retry once
           continue;
         }
         throw new Error(`mumpix: database is locked: ${this.filePath}`);
       }
     }
+
     throw new Error(`mumpix: failed to acquire lock: ${this.filePath}`);
   }
 
   _releaseLock() {
     if (this._lockFd !== null) {
-      try { fs.closeSync(this._lockFd); } catch (_) {}
+      try {
+        fs.closeSync(this._lockFd);
+      } catch (_) {}
       this._lockFd = null;
     }
-    try { fs.unlinkSync(this.lockPath); } catch (_) {}
+    try {
+      fs.unlinkSync(this.lockPath);
+    } catch (_) {}
   }
 
   _canRecoverFromIntegrityError(err) {
     if (!this._strictIntegrity) return false;
     if (!fs.existsSync(this.walPath)) return false;
-    const msg = String((err && err.message) || err || '');
-    return msg.includes('integrity hash mismatch') ||
-      msg.includes('invalid record order/id') ||
-      msg.includes('Unexpected token') ||
-      msg.includes('corrupt or empty file');
+    const message = String((err && err.message) || err || "");
+    return (
+      message.includes("integrity hash mismatch") ||
+      message.includes("invalid record order/id") ||
+      message.includes("Unexpected token") ||
+      message.includes("corrupt or empty file")
+    );
   }
 
   _recoverFromTailCorruption() {
-    const raw = fs.readFileSync(this.filePath, 'utf8');
-    const lines = raw.split('\n').filter(l => l.trim());
+    const lines = fs
+      .readFileSync(this.filePath, "utf8")
+      .split("\n")
+      .filter((line) => line.trim());
     if (!lines.length) return false;
 
     let header;
@@ -419,107 +491,84 @@ class MumpixStore {
       return false;
     }
 
-    const good = [];
-    const seenIds = new Set();
+    const recovered = [];
+    const seen = new Set();
     let lastId = 0;
-    let badFound = false;
+    let truncated = false;
 
     for (let i = 1; i < lines.length; i++) {
       try {
-        const r = JSON.parse(lines[i]);
-        const validShape = r && Number.isInteger(r.id) && typeof r.content === 'string' && r.content.length > 0;
-        const monotonic = validShape && r.id > lastId;
-        const duplicate = validShape && seenIds.has(r.id);
-        const hashOk = validShape && this._verifyHash(r);
-        if (!validShape || !monotonic || duplicate || !hashOk) {
-          badFound = true;
+        const record = JSON.parse(lines[i]);
+        const shape =
+          record &&
+          Number.isInteger(record.id) &&
+          typeof record.content === "string" &&
+          record.content.length > 0;
+        const ordered = shape && record.id > lastId;
+        const duplicate = shape && seen.has(record.id);
+        const validHash = shape && this._verifyHash(record);
+        if (!shape || !ordered || duplicate || !validHash) {
+          truncated = true;
           break;
         }
-        good.push(r);
-        seenIds.add(r.id);
-        lastId = r.id;
+        recovered.push(record);
+        seen.add(record.id);
+        lastId = record.id;
       } catch (_) {
-        badFound = true;
+        truncated = true;
         break;
       }
     }
 
-    if (!badFound) return false;
-    this._rewriteSnapshot(header, good);
+    if (!truncated) return false;
+    this._rewriteSnapshot(header, recovered);
     return true;
   }
 
   _rewriteSnapshot(header, records) {
-    const tmp = this.filePath + '.tmp.' + process.pid;
+    const tmp = `${this.filePath}.tmp.${process.pid}`;
     const lines = [JSON.stringify(header)];
-    for (const r of records) lines.push(JSON.stringify(r));
-    fs.writeFileSync(tmp, lines.join('\n') + '\n', 'utf8');
+    for (const record of records) lines.push(JSON.stringify(record));
+    fs.writeFileSync(tmp, `${lines.join("\n")}\n`, "utf8");
     fs.renameSync(tmp, this.filePath);
   }
 
-  _hash(s, prevH = '0', id = 0) {
-    const secret = process.env.MUMPIX_INTEGRITY_SECRET || '';
-    const h = crypto.createHmac('sha256', secret)
-      .update(String(s) + String(prevH) + String(id))
-      .digest('hex');
-    return `sha256:${h}`;
-  }
-
-  _verifyHash(record, prevH = '0') {
-    if (!record || typeof record.content !== 'string' || typeof record.h !== 'string') return false;
-    
-    // Support modern SHA-256 chaining
-    if (record.h.startsWith('sha256:')) {
-      const match = this._hash(record.content, prevH, record.id) === record.h;
-      if (!match) return false;
+  _hash(content) {
+    const secret = process.env.MUMPIX_INTEGRITY_SECRET;
+    if (secret && secret.trim()) {
+      return `hmac256:${crypto
+        .createHmac("sha256", secret)
+        .update(String(content), "utf8")
+        .digest("hex")}`;
+    }
 
-      // In Verified mode, also check the ML-DSA signature if present
-      if (this.header.consistency === 'verified' && this._mlDsa && this._publicKey) {
-        if (!record.sig) return false; // Signature mandatory in Verified mode
-        try {
-          const msg = Buffer.from(record.h, 'utf8');
-          const sig = Buffer.from(record.sig, 'hex');
-          return this._mlDsa.verify(sig, msg, this._publicKey);
-        } catch {
-          return false;
-        }
-      }
-      return true;
+    let hash = 2166136261;
+    for (let i = 0; i < content.length; i++) {
+      hash ^= content.charCodeAt(i);
+      hash = Math.imul(hash, 16777619);
     }
+    return `0x${(hash >>> 0).toString(16).padStart(8, "0")}`;
+  }
 
-    // Support legacy hmac256 (non-chained)
-    if (record.h.startsWith('hmac256:')) {
+  _verifyHash(record) {
+    if (!record || typeof record.content !== "string" || typeof record.h !== "string") {
+      return false;
+    }
+    if (record.h.startsWith("hmac256:")) {
       const secret = process.env.MUMPIX_INTEGRITY_SECRET;
-      if (!secret || !secret.trim()) return false;
-      const digest = crypto
-        .createHmac('sha256', secret)
-        .update(String(record.content), 'utf8')
-        .digest('hex');
-      return `hmac256:${digest}` === record.h;
+      return !!(secret && secret.trim()) && this._hash(record.content) === record.h;
     }
-    
-    // Backward compatibility for legacy FNV-1a records while migrating.
     return this._hashLegacy(record.content) === record.h;
   }
 
-  _hashLegacy(s) {
-    let h = 0x811c9dc5;
-    for (let i = 0; i < s.length; i++) {
-      h ^= s.charCodeAt(i);
-      h = Math.imul(h, 0x01000193);
+  _hashLegacy(content) {
+    let hash = 2166136261;
+    for (let i = 0; i < content.length; i++) {
+      hash ^= content.charCodeAt(i);
+      hash = Math.imul(hash, 16777619);
     }
-    return '0x' + (h >>> 0).toString(16).padStart(8, '0');
+    return `0x${(hash >>> 0).toString(16).padStart(8, "0")}`;
   }
 }
 
-function sanitizeMeta(meta) {
-  if (!meta || typeof meta !== 'object') return {};
-  const out = {};
-  if (Number.isFinite(meta.ts)) out.ts = Number(meta.ts);
-  if (typeof meta.workspace === 'string' && meta.workspace.trim()) out.workspace = meta.workspace.trim();
-  if (typeof meta.repo === 'string' && meta.repo.trim()) out.repo = meta.repo.trim();
-  if (typeof meta.source === 'string' && meta.source.trim()) out.source = meta.source.trim();
-  return out;
-}
-
 module.exports = { MumpixStore };