mumpix 1.0.18 → 1.0.19

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## 1.0.19 - 2026-04-13
+
+### Internal & Sync
+- Synchronized latest temporal engine and operator scripts from core module into the package tree.
+- Configured embedded GGUF agent context window ceilings (8K) to prevent VRAM memory allocation conflicts with local LLMs (e.g., `mumpix-mlc-llm`).
+
+## 1.0.18 - 2026-03-30
+- General performance and sync updates
+
+## 1.0.17 - 2026-03-24
+- Core temporal sync patches
+
 ## 1.0.11 - 2026-03-03
 
 ## 1.0.12 - 2026-03-03

package/README.md

@@ -95,6 +95,69 @@ await db.stats();
 await db.close();
 ```
 
+### Temporal API
+
+`mumpix` also exposes a deterministic temporal layer built on top of WAL-backed records.
+
+This is meant to answer timeline questions by computing over normalized events, not by asking a model to guess from raw text.
+
+```js
+const { Mumpix } = require('mumpix');
+
+const db = await Mumpix.open('./agent.mumpix', { consistency: 'eventual' });
+
+await db.remember({
+  content: 'I set up the smart thermostat on March 1st.',
+  workspace: 'home',
+  repo: 'infra-home',
+  source: 'ops-log',
+  ts: Date.parse('2026-03-03T09:10:00Z'),
+});
+
+await db.remember({
+  content: 'I set up the mesh network system on March 3rd.',
+  workspace: 'home',
+  repo: 'infra-home',
+  source: 'ops-log',
+  ts: Date.parse('2026-03-03T09:00:00Z'),
+});
+
+const events = await db.events();
+const index = await db.eventIndex();
+const result = await db.temporalQuery(
+  'Which device did I set up first, the smart thermostat or the mesh network system?'
+);
+
+console.log(events.length);
+console.log(Array.from(index.byWorkspace.keys()));
+console.log(result.value); // smart thermostat
+```
+
+Available temporal package APIs:
+
+- `db.events({ query?, topK? })`
+- `db.eventIndex({ query?, topK? })`
+- `db.temporalQuery(query, { topK?, now? })`
+
+Low-level exports are also available for advanced use:
+
+```js
+const { temporal, temporalEngine, temporalIndexes } = require('mumpix');
+```
+
+These expose:
+
+- deterministic event operators
+- event materialization
+- event indexing by title, type, workspace, repo, and source
+
+Temporal records support scoped metadata on write:
+
+- `workspace`
+- `repo`
+- `source`
+- `ts`
+
 ### Consistency modes
 
 | Mode | Behavior | Use case |
@@ -159,6 +222,7 @@ Examples:
 ```bash
 node examples/langchain-adapter.js
 node examples/llamaindex-adapter.js
+node examples/temporal-memory.js
 ```
 
 ## CLI

package/examples/temporal-memory.js

@@ -0,0 +1,80 @@
+'use strict';
+
+/**
+ * examples/temporal-memory.js
+ *
+ * Run:
+ *   node examples/temporal-memory.js
+ */
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { Mumpix } = require('../src/index');
+
+async function main() {
+  const dbPath = path.join(os.tmpdir(), `mumpix-temporal-${process.pid}.mumpix`);
+  const db = await Mumpix.open(dbPath, { consistency: 'eventual' });
+
+  try {
+    await db.rememberAll([
+      {
+        content: 'I set up the mesh network system on March 3rd.',
+        workspace: 'home',
+        repo: 'infra-home',
+        source: 'ops-log',
+        ts: Date.parse('2026-03-03T09:00:00Z'),
+      },
+      {
+        content: 'I set up the smart thermostat on March 1st.',
+        workspace: 'home',
+        repo: 'infra-home',
+        source: 'ops-log',
+        ts: Date.parse('2026-03-03T09:10:00Z'),
+      },
+      {
+        content: 'I deployed the schema migration on January 10th.',
+        workspace: 'client-b',
+        repo: 'billing-api',
+        source: 'deploy-log',
+        ts: Date.parse('2026-01-10T09:00:00Z'),
+      },
+      {
+        content: 'I noticed the payment queue was not functioning correctly on January 12th.',
+        workspace: 'client-b',
+        repo: 'billing-api',
+        source: 'incident-log',
+        ts: Date.parse('2026-01-12T09:00:00Z'),
+      },
+    ]);
+
+    const events = await db.events();
+    console.log('events:', events.map((event) => ({
+      title: event.title,
+      type: event.event_type,
+      date: event.event_date,
+      workspace: event.workspace,
+      repo: event.repo,
+      source: event.source,
+    })));
+
+    const index = await db.eventIndex();
+    console.log('workspaces indexed:', Array.from(index.byWorkspace.keys()));
+
+    const firstSetup = await db.temporalQuery('Which device did I set up first, the smart thermostat or the mesh network system?');
+    console.log('first setup:', firstSetup.value);
+
+    const daysBetween = await db.temporalQuery('How many days had passed between "schema migration" and "payment queue"?');
+    console.log('days between deploy and issue:', daysBetween.value);
+  } finally {
+    await db.close();
+    for (const suffix of ['', '.wal', '.lock']) {
+      try { fs.unlinkSync(dbPath + suffix); } catch (_) {}
+    }
+  }
+}
+
+main().catch((error) => {
+  console.error(error);
+  process.exit(1);
+});

package/package.json

@@ -1,17 +1,18 @@
 {
   "name": "mumpix",
-  "version": "1.0.18",
+  "version": "1.0.19",
   "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 release:clean && npm pack --cache /tmp/mumpix-npm-cache"
+    "release:pack": "npm run build && npm run release:clean && node ./scripts/obfuscate.cjs && npm pack --cache /tmp/mumpix-npm-cache ; node ./scripts/restore.cjs"
   },
   "keywords": [
     "ai",
@@ -55,5 +56,8 @@
     "CHANGELOG.md",
     "README.md",
     "LICENSE"
-  ]
+  ],
+  "devDependencies": {
+    "javascript-obfuscator": "^5.4.1"
+  }
 }

package/src/core/MumpixDB.js

@@ -18,6 +18,8 @@ const { MumpixAudit } = require('./audit');
 const { recall, recallMany } = require('./recall');
 const { LicenseManager } = require('./license');
 const { getStoredLicenseKey } = require('./auth');
+const { answerTemporalQuery, materializeEvents, materializeEventIndex, extractEventsFromRecord } = require('../temporal/engine');
+const { appendEventIndex } = require('../temporal/indexes');
 
 const VALID_MODES = ['eventual', 'strict', 'verified'];
 
@@ -34,6 +36,7 @@ class MumpixDB {
     this._opts = opts;
     this._closed = false;
     this._license = license;
+    this._temporalCache = null;
   }
 
   // ─────────────────────────────────────────
@@ -63,16 +66,17 @@ class MumpixDB {
     const store = new MumpixStore(filePath);
     let auditLog = null;
     try {
-      store.open({ consistency: requestedConsistency });
+      await store.open({ consistency: requestedConsistency });
 
       // License initialization & check.
       // Allow dependency injection for local verification and integration tests.
       const resolvedLicenseKey = opts.licenseKey || getStoredLicenseKey() || null;
-      const license = opts.licenseManager instanceof LicenseManager
-        ? opts.licenseManager
-        : new LicenseManager(resolvedLicenseKey);
+      const license = new LicenseManager(resolvedLicenseKey);
       license.setFileContext(store.header && store.header.fileId ? store.header.fileId : null);
-      await license.init();
+      const licenseReady = await license.init();
+      if (resolvedLicenseKey && !licenseReady) {
+        console.warn(`[DEBUG] License rejected: ${license.validationError}`);
+      }
 
       // Capability-gated mode check with graceful downgrade policy:
       // if a paid mode (strict/verified) is requested with expired/invalid license,
@@ -84,6 +88,7 @@ class MumpixDB {
           license.assertActive(requestedConsistency);
         } catch (modeErr) {
           const msg = String(modeErr && modeErr.message ? modeErr.message : modeErr).toLowerCase();
+          console.warn(`[DEBUG] Mode check failed: ${msg}`);
           const downgradeable =
             msg.includes('expired') ||
             msg.includes('invalid for mode') ||
@@ -97,9 +102,10 @@ class MumpixDB {
       }
 
       if (effectiveConsistency !== requestedConsistency) {
+        console.warn(`[DEBUG] Downgrading consistency to ${effectiveConsistency}`);
         // Re-open with downgraded mode after releasing current FD/lock first.
         store.close();
-        store.open({ consistency: effectiveConsistency });
+        await store.open({ consistency: effectiveConsistency });
       }
 
       if (effectiveConsistency === 'verified') {
@@ -134,16 +140,31 @@ class MumpixDB {
    * @param {string} content
    * @returns {{ id: number, written: boolean, consistency: string }}
    */
-  async remember(content) {
+  async remember(content, opts = {}) {
     this._assertOpen();
-    if (typeof content !== 'string' || !content.trim()) {
-      throw new TypeError('remember() requires a non-empty string');
+    let text = content;
+    let meta = opts;
+
+    if (content && typeof content === 'object' && !Array.isArray(content)) {
+      text = content.content;
+      meta = {
+        ...opts,
+        workspace: content.workspace ?? opts.workspace,
+        repo: content.repo ?? opts.repo,
+        source: content.source ?? opts.source,
+        ts: content.ts ?? opts.ts,
+      };
+    }
+
+    if (typeof text !== 'string' || !text.trim()) {
+      throw new TypeError('remember() requires a non-empty string or { content } object');
     }
 
     // License Check for Record Limit
     this._license.checkLimit('records', this._store.records.length);
 
-    const record = this._store.write(content);
+    const record = this._store.write(text, meta);
+    this._appendTemporalRecord(record);
 
     if (this._audit) {
       this._audit.logWrite(record);
@@ -234,6 +255,104 @@ class MumpixDB {
     }));
   }
 
+  /**
+   * Materialize normalized temporal events from WAL-backed records.
+   *
+   * @param {object} [opts]
+   * @param {string} [opts.query]  Optional query to shortlist candidate records first
+   * @param {number} [opts.topK=50]
+   * @returns {Array<object>}
+   */
+  async events(opts = {}) {
+    this._assertOpen();
+    const records = this._store.all();
+    if (!records.length) return [];
+
+    if (!opts.query) {
+      return this._getTemporalCache().events;
+    }
+
+    if (opts.query && typeof opts.query === 'string' && opts.query.trim()) {
+      const topK = Number.isFinite(opts.topK) ? Number(opts.topK) : 50;
+      const shortlisted = await recallMany(opts.query, records, {
+        embedFn: this._opts.embedFn,
+        k: topK,
+      });
+      return materializeEvents(shortlisted);
+    }
+
+    return this._getTemporalCache().events;
+  }
+
+  /**
+   * Return derived event indexes built from WAL-backed records.
+   *
+   * @param {object} [opts]
+   * @param {string} [opts.query]
+   * @param {number} [opts.topK=50]
+   * @returns {object}
+   */
+  async eventIndex(opts = {}) {
+    this._assertOpen();
+    const records = this._store.all();
+    if (!records.length) {
+      return materializeEventIndex([]);
+    }
+
+    if (!opts.query) {
+      return this._getTemporalCache();
+    }
+
+    const topK = Number.isFinite(opts.topK) ? Number(opts.topK) : 50;
+    const shortlisted = await recallMany(opts.query, records, {
+      embedFn: this._opts.embedFn,
+      k: topK,
+    });
+    return materializeEventIndex(shortlisted);
+  }
+
+  /**
+   * Run a deterministic temporal query over WAL-backed records.
+   *
+   * @param {string} query
+   * @param {object} [opts]
+   * @param {number} [opts.topK=50]
+   * @param {Date|string|number} [opts.now]
+   * @returns {object}
+   */
+  async temporalQuery(query, opts = {}) {
+    this._assertOpen();
+    if (typeof query !== 'string' || !query.trim()) {
+      throw new TypeError('temporalQuery() requires a non-empty string');
+    }
+
+    const records = this._store.all();
+    if (!records.length) {
+      return {
+        ok: false,
+        kind: null,
+        value: null,
+        evidence: [],
+        warnings: ['No records available.'],
+        parsed_query: null,
+        events: [],
+      };
+    }
+
+    const topK = Number.isFinite(opts.topK) ? Number(opts.topK) : 50;
+    const shortlisted = await recallMany(query, records, {
+      embedFn: this._opts.embedFn,
+      k: topK,
+    });
+
+    const now =
+      opts.now instanceof Date ? opts.now :
+      (typeof opts.now === 'string' || typeof opts.now === 'number') ? new Date(opts.now) :
+      new Date();
+
+    return answerTemporalQuery(query, shortlisted, { now });
+  }
+
   /**
    * Delete all memories.
    *
@@ -242,6 +361,7 @@ class MumpixDB {
   async clear() {
     this._assertOpen();
     const count = this._store.clear();
+    this._invalidateTemporalCache();
 
     if (this._audit) {
       this._audit.logClear(count);
@@ -366,6 +486,34 @@ class MumpixDB {
     if (this._closed) throw new Error('Database is closed. Call Mumpix.open() again.');
     this._license.assertActive(this._store.header.consistency);
   }
+
+  _invalidateTemporalCache() {
+    this._temporalCache = null;
+  }
+
+  _temporalSignature() {
+    const records = this._store.records || [];
+    const last = records.length ? records[records.length - 1] : null;
+    return `${records.length}:${last ? last.id : 0}:${last ? last.ts : 0}`;
+  }
+
+  _getTemporalCache() {
+    const signature = this._temporalSignature();
+    if (this._temporalCache && this._temporalCache.signature === signature) {
+      return this._temporalCache.index;
+    }
+
+    const index = materializeEventIndex(this._store.all());
+    this._temporalCache = { signature, index };
+    return index;
+  }
+
+  _appendTemporalRecord(record) {
+    if (!this._temporalCache) return;
+    const events = extractEventsFromRecord(record);
+    appendEventIndex(this._temporalCache.index, events);
+    this._temporalCache.signature = this._temporalSignature();
+  }
 }
 
 module.exports = { MumpixDB };

package/src/core/license.js

@@ -7,7 +7,7 @@ const https = require('https');
 const path = require('path');
 
 // Default embedded public key (official issuer).
-const DEFAULT_MASTER_PUBLIC_KEY_B64 = `szA4EoME83k0zoSQnzMWSC5BOEnr1VazfZlyP4JKqufZHIjlc0TalnK4gi4Jsn0PMHAJlzEOp/0PvUiW8L0RN3rj0pKEkuwDY5c1Q5C2u1Dh7VfcyiCzj+JusviaANuJQxoEdi6yeBUXJO7tZpwpTrekF5hrc5V9ccY0U3gAofg+4prZz0bA7aaLxK+/WIYXtO+PR7VOAavMzR536FAdJtfcgz08L1hu7RUiE38hQnAH2yRuBkmcGesw4k0XSx3HZXjVwaVxZsOZpL3DihS2EwbluDIzrb3Tz5nf7a2ak/FRFcTS+LLjM4ywxuq6toKT/laAOt/0AEVp67nFGVm8OU4blpmgO3gA0APpglrVMGFcxrBQyYLqMsgwxmb6dQMydILriHQ9vN+jR8jD3qs5f14FwsZkkMtBgBMNRFybQvrXOxvPF36rknnkeDuE0W+9sSpzOdzM8/UZKInzh+v0yOYPIW1y9oiJb2RtoIz0kJkg0IwR8JOIZ7Svfa62ifT/CFhIsBr6zIVdK7mlxmDqiD3MnlLvfqhyPfdgIbCRLmClXI6Jjpt4d7shzBHvOxCpEGwYw4hVCGTnVhPne8UWmgqU3BkSVBQsHU/7s6jNH/tvZjfkOgWoz81RrnrE8xMGRh5yn/F/bEa0igbyJ/4XlmAPRMkQ+CCIo/NbBlYtKvnMHTwatj3B4Z06hTFl0rnuGbQ9u9JXp/1x7bVztMdSM/T65VW8H/zcvZ7aZTbEMzcTUqMdo9IwOWVfyb6lwg5FSCANKzmyT//CJQtpacS9TjPZ0m4AOFyAwhj57fxY7xMPSYQIyTrpMRkoNACJ9QoSSAnyJ0u1aBTMbiFr8IgjgZm0XL2giz8yD5bi/kS+85qPGut+Hvx66VztumAQUoLpJYJSgVXO4ZYMNY0DraTE48l3Y2RG/KmerSGbjAjZjXPJlKxF94M8Y4Su18iy0BVpS7Ax+8nEzDPVfTqPUoSJctv/YLY6bdMqhi9/rTIrE/3Htm5YwHfZP+BV59JLFflT7iud4nBuRZ5rF7ONGMDELg/sglBOHqkv7bDaSoxgcD2SA0L3sptnW57ohUHwmFWuSE8zYkoUsT0sCwvClbmpcgPUxisSY3duAEC3Q+l+NibYhXsavUuHZ9h/O2oMUUvIxtmcF1t17c1f6QwhYpZlJYuYZ/wWTGWqD5MADslUUHCvla5hoZRhWOsDdQspP8O1Sa2Cpzh8zWuKAr2YaSNsUQi/orwzfWFZ56ss9JAH9d+W1Sqc0qOxeQgMoSF3UmHalDQ+xrRl/b1fcN5ZBNmDaM1o0JHGNl7gB7q0Va7NXH2KD1k21f7POPIAdTXlqquFS+MOdy+atPnhncht3bVzSRcerelIk/YGxKCJbsXqFB38s2tR7u4D56B6LiIl/1x4UmP9MmgvJDPMDwrpD9ExgCIyoordPiixYuOeq5LVG6VanIrrVgRlrGmW2lbVX5PMZfZsfhCPW9/JrvrqBPVtnqAjcappUGG4yJyHYFIXeE6Z1nd5DKdBHXEl6zACV6SwxJJ6qgapyOrXCnTmXqkmtI0ebJWGRJ+NHtgl29FF4LXV7HmNgrYrSFdgc6tv/ZBycEFPmsc/HK2Omo+dQKmVI/6w95ctKOsTQmim+pqz5QcZYE8LnCm+U/8iosivWaJ2s6jB+YXQ6Y4+IF9vSPonyqOViw97Moe9uq7qkSM+sfm2pL/oyGTsluOUftREbtIWFK4f4L9EEIWp9em/dAP6mQ==`;
+const DEFAULT_MASTER_PUBLIC_KEY_B64 = `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`;
 
 function activeMasterPublicKeyB64() {
   return String(process.env.MUMPIX_LICENSE_PUBLIC_KEY_B64 || DEFAULT_MASTER_PUBLIC_KEY_B64).trim();
@@ -36,10 +36,6 @@ class LicenseManager {
       : 'free';
   }
 
-  // Capability matrix for Option B model.
-  // free/community: eventual only
-  // developer/teams: eventual + strict
-  // compliance/enterprise: eventual + strict + verified
   _capsForTier(tier) {
     const t = this._normalizeTier(tier);
     if (t === 'monthly') return { modes: ['eventual', 'strict'] };
@@ -62,13 +58,10 @@ class LicenseManager {
 
   _maxDaysForTier(tier) {
     const t = this._normalizeTier(tier);
-    // Monthly subscriptions default to 45-day lease windows for offline/air-gapped tolerance.
     if (t === 'monthly') return envInt('MUMPIX_LICENSE_MAX_DAYS_MONTHLY', 45);
     if (t === 'standard') return envInt('MUMPIX_LICENSE_MAX_DAYS_STANDARD', 45);
     if (t === 'developer') return envInt('MUMPIX_LICENSE_MAX_DAYS_DEVELOPER', 365);
     if (t === 'teams') return envInt('MUMPIX_LICENSE_MAX_DAYS_TEAMS', 365);
-    // Enterprise / government / compliance can be long-lived for air-gapped installs.
-    // Defaults allow up to 100 years, and operators can tighten/expand via env.
     if (t === 'enterprise') return envInt('MUMPIX_LICENSE_MAX_DAYS_ENTERPRISE', 36500);
     if (t === 'government') return envInt('MUMPIX_LICENSE_MAX_DAYS_GOVERNMENT', 36500);
     if (t === 'compliance' || t === 'verified' || t === 'pro') {
@@ -160,8 +153,8 @@ class LicenseManager {
         globalThis.crypto = require('node:crypto').webcrypto;
       }
       const mlDsaPath = 'file://' + path.resolve(__dirname, 'ml-dsa.mjs');
-      const { ml_dsa44 } = await import(mlDsaPath);
-      this._ml_dsa = ml_dsa44;
+      const { ml_dsa65 } = await import(mlDsaPath);
+      this._ml_dsa = ml_dsa65;
       return await this.validate(this.key);
     } catch (e) {
       console.error('Mumpix Licensing Initialization Failed:', e.message);
@@ -177,12 +170,18 @@ class LicenseManager {
       const payloadRaw = Buffer.from(payloadB64, 'base64').toString();
       const payload = JSON.parse(payloadRaw);
 
-      // Verify Quantum-Safe Signature (ML-DSA-44)
       const msg = Buffer.from(payloadB64, 'utf-8');
       const sig = Buffer.from(signatureB64, 'base64');
-      const pub = Buffer.from(activeMasterPublicKeyB64(), 'base64');
+      const pubB64 = activeMasterPublicKeyB64();
+      const pub = Buffer.from(pubB64, 'base64');
+      
+      console.log('[CRYPTO DEBUG] Payload Length:', msg.length);
+      console.log('[CRYPTO DEBUG] Sig Length:', sig.length);
+      console.log('[CRYPTO DEBUG] Pub Length:', pub.length);
+      console.log('[CRYPTO DEBUG] Pub Start (B64):', pubB64.substring(0, 20));
 
       const isValid = this._ml_dsa.verify(sig, msg, pub);
+      console.log('[CRYPTO DEBUG] isValid:', isValid);
       if (!isValid) throw new Error('Quantum signature verification failed');
 
       this._validateLeaseWindow(payload);
@@ -191,8 +190,6 @@ class LicenseManager {
         throw new Error('License key has expired');
       }
 
-      // Optional binding for newly issued licenses.
-      // Backward-compatible: if fid missing from payload, accept legacy license.
       if (payload.fid && this.fileId && String(payload.fid) !== String(this.fileId)) {
         throw new Error('License key is bound to a different file');
       }
@@ -214,7 +211,6 @@ class LicenseManager {
   }
 
   checkLimit(type, currentCount) {
-    // Option B: no record count gate. Gating is by capabilities/mode.
     if (type === 'records') return true;
 
     if (type === 'mode') {
@@ -222,15 +218,15 @@ class LicenseManager {
       const caps = this._capsForTier(this.tier);
       if (!caps.modes.includes(requested)) {
         if (this.key && !this.verified && this.validationError) {
-          throw new Error(`Mumpix license is invalid for mode "${requested}": ${this.validationError}`);
+          throw new Error(`Mumpix license is invalid for mode ${requested}: ${this.validationError}`);
         }
         if (requested === 'strict') {
-          throw new Error('MumpixDB "strict" mode requires Developer tier or higher. Upgrade at mumpixdb.com.');
+          throw new Error('MumpixDB strict mode requires Developer tier or higher. Upgrade at mumpixdb.com.');
         }
         if (requested === 'verified') {
-          throw new Error('MumpixDB "verified" mode requires Compliance tier. Upgrade at mumpixdb.com.');
+          throw new Error('MumpixDB verified mode requires Compliance tier. Upgrade at mumpixdb.com.');
         }
-        throw new Error(`MumpixDB mode "${requested}" is not available on your current tier.`);
+        throw new Error(`MumpixDB mode ${requested} is not available on your current tier.`);
       }
       return true;
     }
@@ -242,7 +238,6 @@ class LicenseManager {
     this.checkLimit('mode', mode);
     const now = Date.now();
     this._enforceClockMonotonic(now);
-    // Expired licenses degrade to eventual mode only. Strict/verified remain blocked until renewal.
     if (this.expiry && now > Number(this.expiry) && mode !== 'eventual') {
       throw new Error('Mumpix license expired. Renew license to continue using this mode.');
     }
@@ -269,4 +264,4 @@ class LicenseManager {
   }
 }
 
-module.exports = { LicenseManager };
+module.exports = { LicenseManager };