@jack200714/mafw 4.5.1

package/gateway/dist/core/auth.js

@@ -0,0 +1,96 @@
+"use strict";
+/**
+ * Gateway auth helpers — single source of truth for all auth checks.
+ *
+ * Channels:
+ *   1. HTTP API: Bearer header / X-API-Token header / ?token= query
+ *   2. WebSocket upgrade: same three channels, but rejection is on the raw socket
+ *   3. Loopback: 127.0.0.0/8, ::1, ::ffff:127.0.0.1 always bypass token checks
+ *
+ * Security notes:
+ *   - Empty apiToken + remote = deny all (not permissive)
+ *   - Tokens are compared with constant-time === (sufficient for short-lived tokens)
+ *   - No plaintext tokens are stored; config holds the canonical value
+ *   - URL token leakage is mitigated by redactLog() in all log paths
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isLoopbackAddr = isLoopbackAddr;
+exports.authorizeRequest = authorizeRequest;
+exports.authorizeWsUpgrade = authorizeWsUpgrade;
+exports.redactLog = redactLog;
+// ---------------------------------------------------------------------------
+// Loopback detection
+// ---------------------------------------------------------------------------
+function isLoopbackAddr(addr) {
+    const a = addr || '';
+    return a === '127.0.0.1' || a.startsWith('127.') || a === '::1' || a === '::ffff:127.0.0.1';
+}
+/**
+ * Returns true when the request is authorized (loopback or valid token).
+ * Used by the HTTP request handler before route dispatch.
+ */
+function authorizeRequest(req, apiToken) {
+    const addr = req.remoteAddress || '';
+    if (isLoopbackAddr(addr))
+        return true;
+    if (!apiToken)
+        return false;
+    const bearer = extractBearer(req);
+    const xToken = extractXApiToken(req);
+    const qToken = extractQueryToken(req);
+    return bearer === apiToken || xToken === apiToken || qToken === apiToken;
+}
+const WS_401_BYTES = Buffer.from('HTTP/1.1 401 Unauthorized\r\n\r\n');
+/**
+ * Authorize a WebSocket upgrade request.  Returns `{ ok: true }` on success,
+ * or `{ ok: false, rejectResponse }` with the bytes to write to the raw socket.
+ *
+ * Accepts the same three channels as HTTP (Bearer / X-API-Token / ?token=).
+ */
+function authorizeWsUpgrade(req, apiToken) {
+    const addr = req.remoteAddress || '';
+    if (isLoopbackAddr(addr))
+        return { ok: true };
+    if (!apiToken)
+        return { ok: false, rejectResponse: WS_401_BYTES };
+    const bearer = extractBearer(req);
+    const xToken = extractXApiToken(req);
+    const qToken = extractQueryToken(req);
+    if (bearer === apiToken || xToken === apiToken || qToken === apiToken) {
+        return { ok: true };
+    }
+    return { ok: false, rejectResponse: WS_401_BYTES };
+}
+// ---------------------------------------------------------------------------
+// Token extraction helpers (private)
+// ---------------------------------------------------------------------------
+function extractBearer(req) {
+    const h = String(req.headers.authorization || '');
+    return h.startsWith('Bearer ') ? h.slice(7) : '';
+}
+function extractXApiToken(req) {
+    return String(req.headers['x-api-token'] || '');
+}
+function extractQueryToken(req) {
+    try {
+        const urlStr = req.url || '/';
+        const host = req.host || req.headers.host || 'localhost';
+        const u = new URL(urlStr, `http://${host}`);
+        return u.searchParams.get('token') || '';
+    }
+    catch {
+        return '';
+    }
+}
+// ---------------------------------------------------------------------------
+// Log redaction
+// ---------------------------------------------------------------------------
+/**
+ * Replace Bearer tokens and token= query values with *** to prevent
+ * plaintext credential leakage in logs.
+ */
+function redactLog(s) {
+    return s
+        .replace(/Bearer\s+[^\s"]+/gi, 'Bearer ***')
+        .replace(/([?&]token=)[^&\s"]+/gi, '$1***');
+}

package/gateway/dist/core/budget-guard.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BudgetGuard = void 0;
+class BudgetGuard {
+    opts;
+    turns = 0;
+    fired = false;
+    detached = false;
+    constructor(opts) {
+        this.opts = opts;
+    }
+    get triggered() { return this.fired; }
+    onStep() {
+        if (this.fired || this.detached)
+            return;
+        this.turns++;
+        const { maxTurns, maxCostUsd } = this.opts;
+        let reason = null;
+        if (typeof maxTurns === 'number' && maxTurns > 0 && this.turns >= maxTurns) {
+            reason = `maxTurns=${maxTurns}`;
+        }
+        else if (typeof maxCostUsd === 'number' && maxCostUsd > 0) {
+            try {
+                if (this.opts.getCostUsd(this.opts.sessionID) >= maxCostUsd)
+                    reason = `maxCostUsd=${maxCostUsd}`;
+            }
+            catch { /* 成本查询失败不阻断 */ }
+        }
+        if (!reason)
+            return;
+        this.fired = true;
+        const sid = this.opts.sessionID;
+        const log = this.opts.log ?? (() => { });
+        log(`[BudgetGuard] ${sid} budget exceeded (${reason}) — aborting`);
+        void (async () => {
+            try {
+                await this.opts.abort(sid);
+            }
+            catch (err) {
+                log(`[BudgetGuard] abort failed (non-fatal): ${err?.message ?? err}`);
+            }
+            try {
+                await this.opts.notify(sid, `[MAFW] 预算上限已触发（${reason}），会话已中止。调整预算后可重新发起。`);
+            }
+            catch (err) {
+                log(`[BudgetGuard] notify failed (non-fatal): ${err?.message ?? err}`);
+            }
+        })();
+    }
+    detach() { this.detached = true; }
+}
+exports.BudgetGuard = BudgetGuard;

package/gateway/dist/core/compression/bm25-index.js

@@ -0,0 +1,176 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BM25Index = void 0;
+const fs = __importStar(require("fs"));
+class BM25Index {
+    invertedIndex = new Map();
+    docLengths = new Map();
+    avgDocLength = 0;
+    k1 = 1.2;
+    b = 0.75;
+    docContents = new Map();
+    constructor(config) {
+        if (config?.k1 !== undefined)
+            this.k1 = config.k1;
+        if (config?.b !== undefined)
+            this.b = config.b;
+    }
+    addDocument(id, text) {
+        const tokens = this.tokenize(text);
+        this.docLengths.set(id, tokens.length);
+        this.docContents.set(id, text);
+        const uniqueTokens = new Set(tokens);
+        for (const token of uniqueTokens) {
+            if (!this.invertedIndex.has(token)) {
+                this.invertedIndex.set(token, new Set());
+            }
+            this.invertedIndex.get(token).add(id);
+        }
+        const totalLength = Array.from(this.docLengths.values()).reduce((a, b) => a + b, 0);
+        this.avgDocLength = totalLength / this.docLengths.size;
+    }
+    search(query, topK = 10) {
+        const tokens = this.tokenize(query);
+        if (tokens.length === 0)
+            return [];
+        const N = this.docLengths.size;
+        if (N === 0)
+            return [];
+        const scores = new Map();
+        for (const token of tokens) {
+            const matchingDocs = this.invertedIndex.get(token);
+            if (!matchingDocs)
+                continue;
+            const df = matchingDocs.size;
+            const idf = Math.log((N - df + 0.5) / (df + 0.5) + 1);
+            for (const docId of matchingDocs) {
+                const docLength = this.docLengths.get(docId) || 0;
+                const tf = this.getTermFreq(docId, token);
+                const numerator = tf * (this.k1 + 1);
+                const denominator = tf + this.k1 * (1 - this.b + this.b * (docLength / this.avgDocLength));
+                const score = idf * (numerator / denominator);
+                scores.set(docId, (scores.get(docId) || 0) + score);
+            }
+        }
+        return Array.from(scores.entries())
+            .sort((a, b) => b[1] - a[1])
+            .slice(0, topK)
+            .map(([id, score]) => ({
+            id,
+            score,
+            text: this.docContents.get(id) || ''
+        }));
+    }
+    removeDocument(id) {
+        for (const [, docSet] of this.invertedIndex) {
+            docSet.delete(id);
+        }
+        for (const [term, docSet] of this.invertedIndex) {
+            if (docSet.size === 0)
+                this.invertedIndex.delete(term);
+        }
+        this.docLengths.delete(id);
+        this.docContents.delete(id);
+        if (this.docLengths.size > 0) {
+            const totalLength = Array.from(this.docLengths.values()).reduce((a, b) => a + b, 0);
+            this.avgDocLength = totalLength / this.docLengths.size;
+        }
+        else {
+            this.avgDocLength = 0;
+        }
+    }
+    clear() {
+        this.invertedIndex.clear();
+        this.docLengths.clear();
+        this.docContents.clear();
+        this.avgDocLength = 0;
+    }
+    save(path) {
+        const data = {
+            invertedIndex: Object.fromEntries(Array.from(this.invertedIndex.entries()).map(([k, v]) => [k, Array.from(v)])),
+            docLengths: Object.fromEntries(this.docLengths),
+            avgDocLength: this.avgDocLength,
+            docContents: Object.fromEntries(this.docContents),
+            k1: this.k1,
+            b: this.b
+        };
+        fs.writeFileSync(path, JSON.stringify(data, null, 2), 'utf-8');
+    }
+    load(path) {
+        const raw = fs.readFileSync(path, 'utf-8');
+        const data = JSON.parse(raw);
+        this.invertedIndex = new Map(Object.entries(data.invertedIndex).map(([k, v]) => [k, new Set(v)]));
+        this.docLengths = new Map(Object.entries(data.docLengths));
+        this.avgDocLength = data.avgDocLength;
+        this.docContents = new Map(Object.entries(data.docContents));
+        this.k1 = data.k1;
+        this.b = data.b;
+    }
+    get size() {
+        return this.docLengths.size;
+    }
+    tokenize(text) {
+        const tokens = text
+            .toLowerCase()
+            .replace(/[^\u4e00-\u9fff\w]/g, ' ')
+            .split(/\s+/)
+            .filter(t => t.length >= 2);
+        return tokens.map(t => {
+            if (t.length < 5)
+                return t;
+            const suffixes = ['ing', 'ed', 'es', 'ly', 'tion', 's'];
+            for (const suffix of suffixes) {
+                if (t.endsWith(suffix) && t.length > suffix.length) {
+                    let stemmed = t.slice(0, -suffix.length);
+                    if (stemmed.length >= 2 && stemmed[stemmed.length - 1] === stemmed[stemmed.length - 2]) {
+                        stemmed = stemmed.slice(0, -1);
+                    }
+                    if (stemmed.length >= 2)
+                        return stemmed;
+                }
+            }
+            return t;
+        });
+    }
+    getTermFreq(docId, term) {
+        const content = this.docContents.get(docId);
+        if (!content)
+            return 1;
+        const tokens = this.tokenize(content);
+        return tokens.filter(t => t === term).length;
+    }
+}
+exports.BM25Index = BM25Index;

package/gateway/dist/core/compression/compression-pipeline.js

@@ -0,0 +1,157 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CompressionPipeline = void 0;
+const observation_deduplicator_1 = require("./observation-deduplicator");
+const observation_classifier_1 = require("./observation-classifier");
+const zero_token_compressor_1 = require("./zero-token-compressor");
+const hybrid_compressor_1 = require("./hybrid-compressor");
+const diff_compressor_1 = require("./diff-compressor");
+const compression_strategy_selector_1 = require("./compression-strategy-selector");
+class CompressionPipeline {
+    deduplicator;
+    classifier;
+    zeroToken;
+    llm;
+    diff;
+    selector;
+    privacyFilter;
+    t1Store;
+    constructor(config) {
+        this.deduplicator = new observation_deduplicator_1.ObservationDeduplicator();
+        this.classifier = new observation_classifier_1.ObservationClassifier();
+        this.zeroToken = new zero_token_compressor_1.ZeroTokenCompressor();
+        this.llm = new hybrid_compressor_1.HybridCompressor(undefined, config?.harmonicIndex, config?.baseDir);
+        this.diff = new diff_compressor_1.DiffCompressor();
+        this.selector = new compression_strategy_selector_1.CompressionStrategySelector();
+        if (config?.privacyFilter) {
+            this.privacyFilter = config.privacyFilter;
+        }
+        this.t1Store = config?.t1Store;
+    }
+    async process(observations) {
+        const stats = {
+            input: observations.length,
+            duplicates: 0,
+            filtered: 0,
+            compressed: 0,
+            merged: 0,
+            output: 0,
+        };
+        let current = [...observations];
+        const deduplicated = this.deduplicator.deduplicate(current);
+        stats.duplicates = current.length - deduplicated.length;
+        current = deduplicated;
+        if (this.t1Store && current.length > 0) {
+            const goalId = current[0]?.goalId;
+            this.t1Store.appendBatch(current, goalId);
+            stats.t1Written = current.length;
+            stats.t1Total = this.t1Store.getCount(goalId);
+        }
+        if (this.privacyFilter) {
+            current = current.map((obs) => this.privacyFilter.filterObservation(obs));
+        }
+        stats.filtered = 0;
+        const groups = this.classifier.classifyBatch(current);
+        const allCompressed = [];
+        for (const [, group] of groups) {
+            const strategy = this.selector.select(group);
+            let compressed;
+            switch (strategy) {
+                case 'diff': {
+                    const diffResult = this.diff.compress(group);
+                    compressed = [diffResult];
+                    break;
+                }
+                case 'zero-token':
+                    compressed = this.zeroToken.compress(group);
+                    break;
+                case 'template':
+                    compressed = this.compressTemplate(group);
+                    break;
+                case 'llm':
+                default: {
+                    const llmResult = await this.llm.compress(group);
+                    compressed = [{
+                            id: llmResult.id,
+                            type: 'llm_compressed',
+                            facts: [llmResult.memory_value || ''],
+                            concepts: llmResult.cue_anchors || [],
+                            energy: llmResult.energy || 0.5,
+                            sourceLoops: group.map((o) => o.loopNum || 0)
+                        }];
+                    break;
+                }
+            }
+            allCompressed.push(...compressed);
+        }
+        stats.compressed = allCompressed.length;
+        const merged = this.mergeSimilar(allCompressed);
+        stats.merged = allCompressed.length - merged.length;
+        stats.output = merged.length;
+        return { compressed: merged, stats };
+    }
+    mergeSimilar(memories) {
+        const merged = [];
+        const used = new Set();
+        for (let i = 0; i < memories.length; i++) {
+            if (used.has(i))
+                continue;
+            let base = { ...memories[i] };
+            used.add(i);
+            for (let j = i + 1; j < memories.length; j++) {
+                if (used.has(j))
+                    continue;
+                const similarity = this.jaccardSimilarity(base.concept, memories[j].concept);
+                if (similarity > 0.85) {
+                    base.facts = this.mergeFacts(base.facts, memories[j].facts);
+                    base.energy = (base.energy + memories[j].energy) / 2;
+                    base.sourceLoops = this.mergeSourceLoops(base.sourceLoops, memories[j].sourceLoops);
+                    used.add(j);
+                }
+            }
+            merged.push(base);
+        }
+        return merged;
+    }
+    jaccardSimilarity(a, b) {
+        if (!a || !b)
+            return 0;
+        const setA = new Set(a.toLowerCase().split(/[-\s_]+/));
+        const setB = new Set(b.toLowerCase().split(/[-\s_]+/));
+        const intersection = new Set([...setA].filter((x) => setB.has(x)));
+        const union = new Set([...setA, ...setB]);
+        return union.size === 0 ? 0 : intersection.size / union.size;
+    }
+    compressTemplate(group) {
+        return group.map((obs) => ({
+            id: `template_${obs.timestamp || Date.now()}`,
+            type: 'observation',
+            fact: typeof obs.content === 'string' ? obs.content.substring(0, 80) : '',
+            concept: 'observation',
+            energy: 0.4,
+            timestamp: obs.timestamp || Date.now(),
+            loopNum: obs.loopNum || 0,
+        }));
+    }
+    mergeFacts(a, b) {
+        if (Array.isArray(a) && Array.isArray(b)) {
+            return [...new Set([...a, ...b])];
+        }
+        if (typeof a === 'string' && typeof b === 'string') {
+            return a !== b ? `${a}; ${b}` : a;
+        }
+        return a || b;
+    }
+    mergeSourceLoops(a, b) {
+        if (Array.isArray(a) && Array.isArray(b)) {
+            return [...new Set([...a, ...b])];
+        }
+        const set = new Set();
+        if (a !== undefined)
+            set.add(a);
+        if (b !== undefined)
+            set.add(b);
+        return [...set];
+    }
+}
+exports.CompressionPipeline = CompressionPipeline;

package/gateway/dist/core/compression/compression-strategy-selector.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CompressionStrategySelector = void 0;
+const zero_token_compressor_1 = require("./zero-token-compressor");
+class CompressionStrategySelector {
+    select(observations) {
+        const allFileEdits = observations.every((o) => o.type === 'file_edit' || (o.content && o.content.includes('File modified')));
+        if (allFileEdits && observations.length > 0) {
+            return 'diff';
+        }
+        const matchRate = this.calculatePatternMatchRate(observations);
+        if (matchRate > 0.8) {
+            return 'zero-token';
+        }
+        if (observations.length < 3 && observations.length > 0) {
+            const allSimple = observations.every((o) => typeof o.content === 'string' && o.content.length < 200);
+            if (allSimple) {
+                return 'template';
+            }
+        }
+        return 'llm';
+    }
+    calculatePatternMatchRate(observations) {
+        if (observations.length === 0)
+            return 0;
+        const compressor = new zero_token_compressor_1.ZeroTokenCompressor();
+        const compressed = compressor.compress(observations);
+        const matched = compressed.filter((c) => c.concept !== 'misc').length;
+        return matched / observations.length;
+    }
+}
+exports.CompressionStrategySelector = CompressionStrategySelector;

package/gateway/dist/core/compression/compression-verifier.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CompressionVerifier = void 0;
+/**
+ * Compression Verifier — 压缩完整性验证器
+ *
+ * 职责：在 L2 Compaction 后，运行 5 项验证清单，确保压缩不丢失关键信息。
+ *
+ * 5 项验证：
+ *   1. loop 不丢失
+ *   2. result 不丢失
+ *   3. domain 不丢失
+ *   4. lesson 核心动作不丢失
+ *   5. violation.rule 不丢失（若存在）
+ */
+class CompressionVerifier {
+    checks = [
+        {
+            ruleId: 'V1',
+            description: 'loop 字段不能丢失',
+            check: (orig, comp) => comp.loop === orig.loop
+        },
+        {
+            ruleId: 'V2',
+            description: 'result 字段不能丢失',
+            check: (orig, comp) => comp.result === orig.result
+        },
+        {
+            ruleId: 'V3',
+            description: 'domain 字段不能丢失',
+            check: (orig, comp) => comp.domain === orig.domain
+        },
+        {
+            ruleId: 'V4',
+            description: 'lesson 核心动作不能丢失',
+            check: (orig, comp) => {
+                const actionVerbs = ['必须', '禁止', '应该', '不得', '需要', 'must', 'must not', 'should', 'need to', 'ensure'];
+                const hasAction = actionVerbs.some(v => orig.lesson.toLowerCase().includes(v.toLowerCase()));
+                if (!hasAction)
+                    return true; // 原 lesson 无动作词，无需检查
+                return actionVerbs.some(v => comp.lesson.toLowerCase().includes(v.toLowerCase()));
+            }
+        },
+        {
+            ruleId: 'V5',
+            description: 'violation.rule 不能丢失（若存在）',
+            check: (orig, comp) => {
+                if (!orig.violation)
+                    return true;
+                return !!comp.violation && comp.violation.rule === orig.violation.rule;
+            }
+        }
+    ];
+    /**
+     * 验证单个 CompactedLesson
+     */
+    verify(original, compacted) {
+        const failures = [];
+        for (const c of this.checks) {
+            if (!c.check(original, compacted)) {
+                failures.push(`[${c.ruleId}] ${c.description}`);
+            }
+        }
+        return { pass: failures.length === 0, failures };
+    }
+    /**
+     * 批量验证 lessons 文件
+     */
+    verifyFile(lessons) {
+        const failures = [];
+        for (const lesson of lessons) {
+            if (!lesson._compacted) {
+                failures.push(`[UNCOMPACTED] Lesson loop=${lesson.loop} 未标记 _compacted`);
+            }
+        }
+        return { pass: failures.length === 0, failures };
+    }
+}
+exports.CompressionVerifier = CompressionVerifier;

package/gateway/dist/core/compression/diff-compressor.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DiffCompressor = void 0;
+class DiffCompressor {
+    compress(fileChanges) {
+        if (!fileChanges || fileChanges.length === 0) {
+            return {
+                type: 'diff',
+                facts: [],
+                concepts: [],
+                energy: 0,
+                sourceLoops: [],
+            };
+        }
+        const files = new Set();
+        let added = 0;
+        let modified = 0;
+        let deleted = 0;
+        const keyPatterns = [/auth/i, /jwt/i, /security/i, /config/i, /api/i];
+        const keyChanges = [];
+        const sourceLoops = new Set();
+        const concepts = new Set();
+        for (const change of fileChanges) {
+            if (change.filePath) {
+                files.add(change.filePath);
+            }
+            if (change.type === 'add' || change.status === 'added') {
+                added++;
+            }
+            else if (change.type === 'delete' || change.status === 'deleted') {
+                deleted++;
+            }
+            else {
+                modified++;
+            }
+            if (change.loopNum !== undefined) {
+                sourceLoops.add(change.loopNum);
+            }
+            const checkText = `${change.filePath || ''} ${change.content || ''}`;
+            for (const pattern of keyPatterns) {
+                if (pattern.test(checkText)) {
+                    keyChanges.push(change.filePath || 'unknown');
+                    break;
+                }
+            }
+            if (change.filePath) {
+                const parts = change.filePath.replace(/\\/g, '/').split('/');
+                for (const part of parts) {
+                    if (part.length > 2 && !concepts.has(part)) {
+                        concepts.add(part);
+                    }
+                }
+            }
+        }
+        const facts = [];
+        facts.push(`Files changed: ${files.size} (${added} added, ${modified} modified, ${deleted} deleted)`);
+        if (keyChanges.length > 0) {
+            facts.push(`Key changes: ${[...new Set(keyChanges)].join(', ')}`);
+        }
+        return {
+            type: 'diff',
+            facts,
+            concepts: [...concepts].slice(0, 10),
+            energy: Math.min(1, fileChanges.length / 10),
+            sourceLoops: [...sourceLoops],
+        };
+    }
+}
+exports.DiffCompressor = DiffCompressor;