mumpix 1.0.19 → 1.1.3

package/package.json

@@ -1,18 +1,17 @@
 {
   "name": "mumpix",
-  "version": "1.0.19",
+  "version": "1.1.3",
   "description": "MumpixDB reasoning ledger and structured memory engine for AI systems",
   "main": "src/index.js",
   "bin": {
     "mumpix": "bin/mumpix.js"
   },
   "scripts": {
-    "build": "node ./scripts/build-package.cjs",
-    "postinstall": "node ./scripts/postinstall-auth.js",
-    "verify:claims": "node ./scripts/verify-claims.cjs",
-    "release:publish-and-deprecate": "node ./scripts/publish-and-deprecate.cjs",
-    "release:clean": "bash ./scripts/release-clean.sh",
-    "release:pack": "npm run build && npm run release:clean && node ./scripts/obfuscate.cjs && npm pack --cache /tmp/mumpix-npm-cache ; node ./scripts/restore.cjs"
+    "bench:semantic": "node ./scripts/bench-semantic.cjs",
+    "bench:recall": "node ./examples/recall-quality-suite.js",
+    "test:phase0": "node ./scripts/test-phase0.cjs",
+    "test:semantic": "node ./scripts/test-semantic.cjs",
+    "test:license-modes": "node ./scripts/test-license-modes.cjs"
   },
   "keywords": [
     "ai",
@@ -48,16 +47,28 @@
   "engines": {
     "node": ">=18.0.0"
   },
+  "peerDependencies": {
+    "@langchain/core": ">=1.1.49",
+    "llamaindex": ">=0.12.1"
+  },
+  "peerDependenciesMeta": {
+    "@langchain/core": {
+      "optional": true
+    },
+    "llamaindex": {
+      "optional": true
+    }
+  },
   "files": [
     "src/",
     "bin/",
-    "scripts/postinstall-auth.js",
-    "examples/",
+    "scripts/bench-semantic.cjs",
+    "scripts/test-phase0.cjs",
+    "scripts/test-semantic.cjs",
+    "scripts/test-license-modes.cjs",
+    "examples/*.js",
     "CHANGELOG.md",
     "README.md",
     "LICENSE"
-  ],
-  "devDependencies": {
-    "javascript-obfuscator": "^5.4.1"
-  }
+  ]
 }

package/scripts/bench-semantic.cjs

@@ -0,0 +1,76 @@
+"use strict";
+
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+const { Mumpix } = require("../src/index");
+
+class BenchEmbedder {
+  constructor() {
+    this.id = "bench-fnv-32-v1";
+    this.dim = 32;
+  }
+
+  async embed(texts) {
+    return texts.map((text) => {
+      const vector = new Float32Array(this.dim);
+      for (const token of String(text).toLowerCase().split(/[^a-z0-9]+/).filter(Boolean)) {
+        let hash = 0x811c9dc5;
+        for (let i = 0; i < token.length; i += 1) {
+          hash ^= token.charCodeAt(i);
+          hash = Math.imul(hash, 0x01000193);
+        }
+        vector[(hash >>> 0) % this.dim] += (hash >>> 16) & 1 ? 1 : -1;
+      }
+      const norm = Math.hypot(...vector) || 1;
+      for (let i = 0; i < this.dim; i += 1) vector[i] /= norm;
+      return vector;
+    });
+  }
+}
+
+(async () => {
+  const count = Number(process.argv[2]) || 5000;
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), "mumpix-semantic-bench-"));
+  const filePath = path.join(dir, "bench.mumpix");
+  const db = await Mumpix.open(filePath, {
+    recall: "semantic",
+    embedder: new BenchEmbedder(),
+    semanticFloor: 0.35,
+  });
+
+  const startedAt = process.hrtime.bigint();
+  for (let i = 0; i < count; i += 1) {
+    await db.remember(`semantic bench record ${i} websocket auth middleware route ${i % 97}`);
+  }
+  const writeSeconds = Number(process.hrtime.bigint() - startedAt) / 1e9;
+
+  const jsonlPath = `${filePath}.vectors.jsonl`;
+  const journalBytes = fs.existsSync(jsonlPath) ? fs.statSync(jsonlPath).size : 0;
+  const closeStartedAt = process.hrtime.bigint();
+  await db.close();
+  const closeSeconds = Number(process.hrtime.bigint() - closeStartedAt) / 1e9;
+  const snapshotBytes = fs.existsSync(`${filePath}.vectors.json`)
+    ? fs.statSync(`${filePath}.vectors.json`).size
+    : 0;
+
+  console.log(
+    JSON.stringify(
+      {
+        records: count,
+        writeSeconds: Number(writeSeconds.toFixed(3)),
+        recordsPerSecond: Number((count / writeSeconds).toFixed(1)),
+        closeSeconds: Number(closeSeconds.toFixed(3)),
+        snapshotBytes,
+        journalBytesBeforeClose: journalBytes,
+      },
+      null,
+      2
+    )
+  );
+
+  fs.rmSync(dir, { recursive: true, force: true });
+})().catch((err) => {
+  console.error(err && err.stack ? err.stack : err);
+  process.exit(1);
+});

package/scripts/test-license-modes.cjs

@@ -0,0 +1,87 @@
+#!/usr/bin/env node
+'use strict';
+
+const crypto = require('crypto');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const { Mumpix } = require('../src');
+const { LicenseManager } = require('../src/core/license');
+
+async function main() {
+  const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'mumpix-license-modes-'));
+  if (!process.env.MUMPIX_CONFIG_DIR) {
+    process.env.MUMPIX_CONFIG_DIR = path.join(tempRoot, 'config');
+  }
+
+  if (typeof globalThis.crypto === 'undefined') {
+    globalThis.crypto = require('node:crypto').webcrypto;
+  }
+  const { ml_dsa44 } = await import('file://' + path.resolve(__dirname, '..', 'src/core/ml-dsa.mjs'));
+
+  const issuer = ml_dsa44.keygen();
+  process.env.MUMPIX_LICENSE_PUBLIC_KEY_B64 = Buffer.from(issuer.publicKey).toString('base64');
+
+  const lm = new LicenseManager();
+  const device = await lm.deviceIdentityInfo();
+  const now = Date.now();
+  const payload = {
+    id: 'local-test-user',
+    tier: 'pro',
+    iat: now,
+    exp: now + 30 * 24 * 60 * 60 * 1000,
+    dpk: device.publicKeyFingerprint,
+    issuer: 'local-ml-dsa-test',
+  };
+
+  const payloadB64 = Buffer.from(JSON.stringify(payload)).toString('base64');
+  const signature = ml_dsa44.sign(Buffer.from(payloadB64, 'utf8'), issuer.secretKey);
+  const licenseKey = `${payloadB64}.${Buffer.from(signature).toString('base64')}`;
+  const licenseSha256 = crypto.createHash('sha256').update(licenseKey).digest('hex');
+
+  console.log('generated_license');
+  console.log(`  tier=${payload.tier}`);
+  console.log(`  exp=${new Date(payload.exp).toISOString()}`);
+  console.log(`  device=${payload.dpk}`);
+  console.log(`  license_sha256=${licenseSha256}`);
+  console.log(`  license_key=${licenseKey}`);
+
+  const modes = ['eventual', 'strict', 'verified'];
+  const results = [];
+  for (const mode of modes) {
+    const dbPath = path.join(os.tmpdir(), `mumpix-${mode}-${Date.now()}-${crypto.randomBytes(4).toString('hex')}.mumpix`);
+    for (const suffix of ['', '.wal', '.lock', '.audit']) {
+      try { fs.unlinkSync(dbPath + suffix); } catch (_) {}
+    }
+
+    const db = await Mumpix.open(dbPath, { consistency: mode, licenseKey });
+    await db.remember(`Mode ${mode} remembers signed license verification`);
+    const recalled = await db.recall('signed license verification');
+    const stats = await db.stats();
+    let auditCount = null;
+    if (mode === 'verified') {
+      auditCount = (await db.audit()).length;
+    }
+    await db.close();
+
+    results.push({
+      mode,
+      effective: db.consistency,
+      records: stats.records,
+      recall: recalled ? 'ok' : 'missing',
+      auditCount,
+    });
+  }
+
+  console.log('mode_results');
+  for (const result of results) {
+    const audit = result.auditCount == null ? '' : ` audit=${result.auditCount}`;
+    console.log(`  ${result.mode}: effective=${result.effective} records=${result.records} recall=${result.recall}${audit}`);
+  }
+}
+
+main().catch((error) => {
+  console.error(error && error.stack ? error.stack : error);
+  process.exit(1);
+});

package/scripts/test-phase0.cjs

@@ -0,0 +1,137 @@
+"use strict";
+
+const assert = require("assert");
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+const { spawn } = require("child_process");
+const { Mumpix } = require("../src/index");
+
+function rmDb(filePath) {
+  for (const suffix of ["", ".wal", ".lock", ".idx"]) {
+    try {
+      fs.rmSync(`${filePath}${suffix}`, { force: true, recursive: true });
+    } catch (_) {}
+  }
+}
+
+async function testNoMatchThreshold() {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), "mumpix-phase0-recall-"));
+  const filePath = path.join(dir, "memory.mumpix");
+  rmDb(filePath);
+
+  const db = await Mumpix.open(filePath, { consistency: "eventual" });
+  try {
+    await db.remember("The sky is blue");
+
+    const miss = await db.recall("quarterly financial projections for the merger");
+    assert.strictEqual(miss, null, "unrelated recall() query should return null");
+
+    const manyMiss = await db.recallMany("quarterly financial projections for the merger", 3);
+    assert.deepStrictEqual(manyMiss, [], "unrelated recallMany() query should return []");
+
+    const hit = await db.recall("sky blue");
+    assert.strictEqual(hit, "The sky is blue", "related query should still recall the matching record");
+
+    const permissive = await db.recall("quarterly financial projections for the merger", {
+      minScore: false,
+    });
+    assert.strictEqual(
+      permissive,
+      "The sky is blue",
+      "minScore:false should preserve explicit opt-out behavior"
+    );
+  } finally {
+    await db.close();
+    rmDb(filePath);
+    fs.rmSync(dir, { force: true, recursive: true });
+  }
+}
+
+async function testSigkillLeavesRecoverableLock() {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), "mumpix-phase0-lock-"));
+  const filePath = path.join(dir, "memory.mumpix");
+  rmDb(filePath);
+
+  const childCode = `
+    const { Mumpix } = require(${JSON.stringify(path.resolve(__dirname, "../src/index"))});
+    (async () => {
+      const db = await Mumpix.open(${JSON.stringify(filePath)}, { consistency: "eventual" });
+      await db.remember("pre-crash record");
+      if (process.send) process.send({ ready: true });
+      setInterval(() => {}, 1000);
+    })().catch((err) => {
+      if (process.send) process.send({ error: err.message });
+      process.exit(1);
+    });
+  `;
+
+  const child = spawn(process.execPath, ["-e", childCode], {
+    stdio: ["ignore", "ignore", "ignore", "ipc"],
+  });
+
+  try {
+    await new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => reject(new Error("child did not open database")), 5000);
+      child.once("message", (message) => {
+        clearTimeout(timeout);
+        if (message && message.error) reject(new Error(message.error));
+        else resolve();
+      });
+      child.once("exit", (code, signal) => {
+        clearTimeout(timeout);
+        reject(new Error(`child exited before ready: code=${code} signal=${signal}`));
+      });
+    });
+
+    assert(fs.existsSync(`${filePath}.lock`), "child should leave a live lock while open");
+    child.kill("SIGKILL");
+
+    await new Promise((resolve) => child.once("exit", resolve));
+
+    const reopened = await Mumpix.open(filePath, { consistency: "eventual" });
+    try {
+      const records = await reopened.list();
+      assert.strictEqual(records.length, 1, "pre-crash record should survive SIGKILL");
+      assert.strictEqual(records[0].content, "pre-crash record");
+    } finally {
+      await reopened.close();
+    }
+  } finally {
+    if (!child.killed) child.kill("SIGKILL");
+    rmDb(filePath);
+    fs.rmSync(dir, { force: true, recursive: true });
+  }
+}
+
+async function testDeadPidLockPayload() {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), "mumpix-phase0-deadpid-"));
+  const filePath = path.join(dir, "memory.mumpix");
+  rmDb(filePath);
+
+  fs.writeFileSync(
+    `${filePath}.lock`,
+    JSON.stringify({ pid: 99999999, ts: Date.now() }),
+    "utf8"
+  );
+
+  const db = await Mumpix.open(filePath, { consistency: "eventual" });
+  try {
+    await db.remember("dead pid lock was removed");
+    assert.strictEqual(await db.recall("dead pid"), "dead pid lock was removed");
+  } finally {
+    await db.close();
+    rmDb(filePath);
+    fs.rmSync(dir, { force: true, recursive: true });
+  }
+}
+
+(async () => {
+  await testNoMatchThreshold();
+  await testSigkillLeavesRecoverableLock();
+  await testDeadPidLockPayload();
+  console.log("phase0 regression tests passed");
+})().catch((err) => {
+  console.error(err && err.stack ? err.stack : err);
+  process.exit(1);
+});