mumpix 1.0.18 → 1.0.20

package/src/core/store.js

@@ -30,14 +30,21 @@ class MumpixStore {
     this._fd      = null;     // open file descriptor for appends
     this._lockFd  = null;     // lock file descriptor
     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)
   }
 
   // ── Public ──────────────────────────────────────
 
-  open(opts = {}) {
+  async open(opts = {}) {
     const consistency = opts.consistency || 'eventual';
     this._strictIntegrity = consistency === 'strict' || consistency === 'verified';
     this._acquireLock(opts);
+    
+    if (consistency === 'verified') {
+      await this._initQuantumEngine();
+    }
 
     if (fs.existsSync(this.filePath)) {
       try {
@@ -101,21 +108,37 @@ class MumpixStore {
       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.
    */
-  write(content) {
+  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:      Date.now(),
-      h:       this._hash(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 } : {}),
     };
 
+    // 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');
+    }
+
     // 1. Write to WAL and force it to disk before touching main file.
     this._appendWal({ op: 'write', entry: record, ts: Date.now() });
 
@@ -179,6 +202,37 @@ class MumpixStore {
     };
   }
 
+  async _initQuantumEngine() {
+    const mlDsaPath = 'file://' + path.resolve(__dirname, 'ml-dsa.mjs');
+    const { ml_dsa65 } = await import(mlDsaPath);
+    this._mlDsa = ml_dsa65;
+
+    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();
+      }
+    }
+  }
+
   // ── Private ─────────────────────────────────────
 
   _load() {
@@ -194,6 +248,7 @@ class MumpixStore {
 
     this.records = [];
     let lastId = 0;
+    let prevH = '0';
     const seenIds = new Set();
     for (let i = 1; i < lines.length; i++) {
       try {
@@ -201,7 +256,7 @@ class MumpixStore {
         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);
+          const hashOk = this._verifyHash(r, prevH);
           if (!monotonic || duplicate || !hashOk) {
             const msg = !hashOk
               ? `mumpix: integrity hash mismatch for id=${r.id}`
@@ -210,6 +265,7 @@ class MumpixStore {
             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;
@@ -237,11 +293,12 @@ class MumpixStore {
           const candidate = entry.entry;
           const exists = seenIds.has(candidate.id);
           const monotonic = Number.isInteger(candidate.id) && candidate.id > lastId;
-          const hashOk = this._verifyHash(candidate);
+          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;
           } else if (this._strictIntegrity) {
@@ -251,6 +308,7 @@ class MumpixStore {
           this.records = [];
           this._nextId = 1;
           seenIds.clear();
+          prevH = '0';
           lastId = 0;
           dirty = true;
         }
@@ -399,31 +457,48 @@ class MumpixStore {
     fs.renameSync(tmp, this.filePath);
   }
 
-  _hash(s) {
-    const secret = process.env.MUMPIX_INTEGRITY_SECRET;
-    if (secret && secret.trim()) {
-      const digest = crypto
-        .createHmac('sha256', secret)
-        .update(String(s), 'utf8')
-        .digest('hex');
-      return `hmac256:${digest}`;
-    }
-    let h = 0x811c9dc5;
-    for (let i = 0; i < s.length; i++) {
-      h ^= s.charCodeAt(i);
-      h = Math.imul(h, 0x01000193);
-    }
-    return '0x' + (h >>> 0).toString(16).padStart(8, '0');
+  _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) {
+  _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;
+
+      // 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;
+    }
+
+    // Support legacy hmac256 (non-chained)
     if (record.h.startsWith('hmac256:')) {
       const secret = process.env.MUMPIX_INTEGRITY_SECRET;
       if (!secret || !secret.trim()) return false;
-      return this._hash(record.content) === record.h;
+      const digest = crypto
+        .createHmac('sha256', secret)
+        .update(String(record.content), 'utf8')
+        .digest('hex');
+      return `hmac256:${digest}` === record.h;
     }
-    // Backward compatibility for legacy records while migrating.
+    
+    // Backward compatibility for legacy FNV-1a records while migrating.
     return this._hashLegacy(record.content) === record.h;
   }
 
@@ -437,4 +512,14 @@ class MumpixStore {
   }
 }
 
+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 };

package/src/index.js

@@ -19,6 +19,9 @@ const { MumpixStore } = require('./core/store');
 const { MumpixAudit } = require('./core/audit');
 const { recall, recallMany, tokenize } = require('./core/recall');
 const { MumpixDevClient, MumpixApiError } = require('./integrations/developer-sdk');
+const temporal = require('./temporal/operators');
+const temporalEngine = require('./temporal/engine');
+const temporalIndexes = require('./temporal/indexes');
 
 // Convenience alias: Mumpix.open() === MumpixDB.open()
 const Mumpix = MumpixDB;
@@ -37,6 +40,11 @@ module.exports = {
   recallMany,
   tokenize,
 
+  // Deterministic temporal event operators
+  temporal,
+  temporalEngine,
+  temporalIndexes,
+
   // Developer SDK (HTTP client for Mumpix services)
   MumpixDevClient,
   MumpixApiError,