@jack200714/mafw 4.5.1

package/gateway/dist/core/memory/l5-store.js

@@ -0,0 +1,141 @@
+"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.L5Store = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+function generateId() {
+    return `l5_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+}
+class L5Store {
+    baseDir;
+    constructor(baseDir) {
+        const { findGlobalMafwDir } = require('../utils/global-path');
+        this.baseDir = baseDir || path.join(findGlobalMafwDir(), 'l5');
+        this.ensureDir();
+    }
+    ensureDir() {
+        if (!fs.existsSync(this.baseDir)) {
+            fs.mkdirSync(this.baseDir, { recursive: true });
+        }
+    }
+    axiomsPath() {
+        return path.join(this.baseDir, 'axioms.json');
+    }
+    heuristicsPath() {
+        return path.join(this.baseDir, 'heuristics.json');
+    }
+    loadAxioms() {
+        try {
+            if (fs.existsSync(this.axiomsPath())) {
+                return JSON.parse(fs.readFileSync(this.axiomsPath(), 'utf-8'));
+            }
+        }
+        catch { }
+        return [];
+    }
+    addAxiom(content, source = 'manual') {
+        const axioms = this.loadAxioms();
+        const existing = axioms.find(a => a.content === content);
+        if (existing) {
+            existing.energy = Math.min(1, existing.energy + 0.1);
+            this.saveAxioms(axioms);
+            return existing;
+        }
+        const axiom = {
+            id: generateId(),
+            content,
+            source,
+            energy: 0.8,
+            created_at: new Date().toISOString(),
+        };
+        axioms.push(axiom);
+        this.saveAxioms(axioms);
+        return axiom;
+    }
+    saveAxioms(axioms) {
+        this.ensureDir();
+        const tmpPath = this.axiomsPath() + '.tmp';
+        fs.writeFileSync(tmpPath, JSON.stringify(axioms, null, 2), 'utf-8');
+        fs.renameSync(tmpPath, this.axiomsPath());
+    }
+    loadHeuristics() {
+        try {
+            if (fs.existsSync(this.heuristicsPath())) {
+                return JSON.parse(fs.readFileSync(this.heuristicsPath(), 'utf-8'));
+            }
+        }
+        catch { }
+        return [];
+    }
+    addHeuristic(pattern, triggerContext, sourceGoalIds) {
+        const heuristics = this.loadHeuristics();
+        const existing = heuristics.find(h => h.pattern === pattern);
+        if (existing) {
+            existing.success_rate = Math.min(1, existing.success_rate + 0.05);
+            existing.energy = Math.min(1, existing.energy + 0.05);
+            this.saveHeuristics(heuristics);
+            return existing;
+        }
+        const heuristic = {
+            id: generateId(),
+            pattern,
+            trigger_context: triggerContext,
+            success_rate: 0.9,
+            source_goal_ids: sourceGoalIds,
+            energy: 0.8,
+            created_at: new Date().toISOString(),
+        };
+        heuristics.push(heuristic);
+        this.saveHeuristics(heuristics);
+        return heuristic;
+    }
+    saveHeuristics(heuristics) {
+        this.ensureDir();
+        const tmpPath = this.heuristicsPath() + '.tmp';
+        fs.writeFileSync(tmpPath, JSON.stringify(heuristics, null, 2), 'utf-8');
+        fs.renameSync(tmpPath, this.heuristicsPath());
+    }
+    getTop(topK = 3) {
+        const axioms = this.loadAxioms()
+            .sort((a, b) => b.energy - a.energy)
+            .slice(0, topK);
+        const heuristics = this.loadHeuristics()
+            .sort((a, b) => b.energy - a.energy)
+            .slice(0, topK);
+        return { axioms, heuristics };
+    }
+}
+exports.L5Store = L5Store;

package/gateway/dist/core/memory/matcher.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TriggerMatcher = void 0;
+/**
+ * Matcher — TriggerCondition 匹配引擎
+ *
+ * 职责：将 Δ 的 trigger_condition 与当前执行上下文精确匹配。
+ *
+ * 支持的条件维度：
+ *   - domain: 如 ['auth', 'api']
+ *   - task_type: 如 ['coding', 'test']
+ *   - affected_file_pattern: glob 模式，如 ['*.test.ts']
+ *   - loop_stage: 如 ['planning', 'executing']
+ *   - keywords: 关键词，Goal 描述中需包含
+ *   - goal_keywords: 目标关键词，与 Goal Charter 匹配
+ *   - min_loop_count: 最小 Loop 数（如 Loop 2+ 才触发）
+ */
+class TriggerMatcher {
+    /**
+     * 判断 trigger_condition 是否匹配当前上下文
+     */
+    match(condition, context) {
+        // 1. min_loop_count
+        if (condition.min_loop_count !== undefined && (context.loopCount ?? 0) < condition.min_loop_count) {
+            return false;
+        }
+        // 2. domain
+        if (condition.domain && context.domain && !condition.domain.includes(context.domain)) {
+            return false;
+        }
+        // 3. task_type
+        if (condition.task_type && context.taskType && !condition.task_type.includes(context.taskType)) {
+            return false;
+        }
+        // 4. loop_stage
+        if (condition.loop_stage && context.loopStage && !condition.loop_stage.includes(context.loopStage)) {
+            return false;
+        }
+        // 5. keywords（Goal 描述关键词）
+        if (condition.keywords && context.goalKeywords) {
+            const hasMatch = condition.keywords.some(kw => context.goalKeywords.some(gk => gk.toLowerCase().includes(kw.toLowerCase())));
+            if (!hasMatch)
+                return false;
+        }
+        // 6. affected_file_pattern（glob 匹配）
+        if (condition.affected_file_pattern && context.affectedFiles) {
+            const hasMatch = condition.affected_file_pattern.some(pat => context.affectedFiles.some(f => this.globMatch(f, pat)));
+            if (!hasMatch)
+                return false;
+        }
+        return true;
+    }
+    /**
+     * 简单 glob 匹配：*.test.ts → 正则
+     */
+    globMatch(file, pattern) {
+        const regex = pattern
+            .replace(/\./g, '\\.')
+            .replace(/\*\*/g, '___GLOBSTAR___')
+            .replace(/\*/g, '[^/\\]*')
+            .replace(/___GLOBSTAR___/g, '.*')
+            .replace(/\?/g, '.');
+        return new RegExp(`^${regex}$`).test(file);
+    }
+}
+exports.TriggerMatcher = TriggerMatcher;

package/gateway/dist/core/memory/merger.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeltaMerger = void 0;
+class DeltaMerger {
+    hookManager;
+    constructor(hookManager) {
+        this.hookManager = hookManager || null;
+    }
+    /**
+     * 合并候选 Δ 列表，去重并解决冲突。
+     */
+    merge(deltas) {
+        const merged = new Map();
+        const conflicts = [];
+        const banned = [];
+        for (const d of deltas) {
+            // 1. 严格去重：相同 ID
+            if (merged.has(d.id)) {
+                const existing = merged.get(d.id);
+                this.hookManager?.execute('memory.contradiction', {
+                    existingId: existing.id,
+                    newId: d.id,
+                    field: 'id',
+                    existingValue: existing.id,
+                    newValue: d.id
+                });
+                if (d.energy_score > existing.energy_score) {
+                    conflicts.push({
+                        deltaId: d.id,
+                        reason: 'superseded',
+                        suggestion: `新版本 energy_score 更高 (${d.energy_score} > ${existing.energy_score})`
+                    });
+                    merged.set(d.id, d);
+                }
+                else {
+                    conflicts.push({
+                        deltaId: d.id,
+                        reason: 'duplicate',
+                        suggestion: '保留能量分更高的版本'
+                    });
+                }
+                continue;
+            }
+            // 2. 语义去重：相同 rule / prompt_delta 内容（简化）
+            const semanticDup = this.findSemanticDuplicate(d, merged.values());
+            if (semanticDup) {
+                conflicts.push({
+                    deltaId: d.id,
+                    reason: 'duplicate',
+                    suggestion: `语义重复于 ${semanticDup.id}`
+                });
+                this.hookManager?.execute('memory.contradiction', {
+                    existingId: semanticDup.id,
+                    newId: d.id,
+                    field: 'content',
+                    existingValue: this.getContent(semanticDup).substring(0, 100),
+                    newValue: this.getContent(d).substring(0, 100)
+                });
+                if (d.energy_score > semanticDup.energy_score) {
+                    merged.set(d.id, d);
+                    merged.delete(semanticDup.id);
+                }
+                continue;
+            }
+            merged.set(d.id, d);
+        }
+        return {
+            merged: Array.from(merged.values()),
+            conflicts,
+            banned
+        };
+    }
+    /**
+     * 查找语义重复的 Δ（简单：rule 或 prompt_delta 前 100 字符相同）
+     */
+    findSemanticDuplicate(d, existing) {
+        const dContent = this.getContent(d).substring(0, 100);
+        for (const e of existing) {
+            if (this.getContent(e).substring(0, 100) === dContent) {
+                return e;
+            }
+        }
+        return null;
+    }
+    getContent(d) {
+        if (d.type === 'constraint')
+            return d.rule || '';
+        if (d.type === 'prompt')
+            return d.prompt_delta || '';
+        if (d.type === 'pattern')
+            return d.pattern_template || '';
+        return '';
+    }
+}
+exports.DeltaMerger = DeltaMerger;

package/gateway/dist/core/memory/migrate-v6.1.js

@@ -0,0 +1,133 @@
+"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.migrateV61 = migrateV61;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const harmonic_types_1 = require("./harmonic-types");
+async function migrateV61(baseDir, indexManager) {
+    const result = { migrated: 0, skipped: 0, errors: [] };
+    const memoryDir = path.join(baseDir, 'memory');
+    for (const dir of ['tier2', 'tier3', 'tier4', 'l5']) {
+        const d = path.join(memoryDir, dir);
+        if (!fs.existsSync(d))
+            fs.mkdirSync(d, { recursive: true });
+    }
+    // lessons/ → tier2/ (episodic)
+    const lessonsDir = path.join(baseDir, 'lessons');
+    if (fs.existsSync(lessonsDir)) {
+        const files = fs.readdirSync(lessonsDir).filter(f => f.endsWith('.yml') || f.endsWith('.yaml') || f.endsWith('.json'));
+        for (const file of files) {
+            try {
+                const content = fs.readFileSync(path.join(lessonsDir, file), 'utf-8');
+                const unit = {
+                    id: (0, harmonic_types_1.generateHarmonicId)(),
+                    type: 'episodic',
+                    primary_abstraction: file.replace(/\.[^.]+$/, '').slice(0, 50),
+                    cue_anchors: extractAnchors(content),
+                    memory_value: content.slice(0, 1000),
+                    energy: 0.5,
+                    created_at: new Date().toISOString(),
+                    updated_at: new Date().toISOString()
+                };
+                const tier2File = path.join(memoryDir, 'tier2.json');
+                const existing = fs.existsSync(tier2File) ? JSON.parse(fs.readFileSync(tier2File, 'utf-8')) : [];
+                existing.push(unit);
+                fs.writeFileSync(tier2File, JSON.stringify(existing, null, 2), 'utf-8');
+                indexManager.addEntry(unit, 'tier2');
+                result.migrated++;
+            }
+            catch (err) {
+                result.errors.push(`lessons/${file}: ${err.message}`);
+            }
+        }
+    }
+    // parametric/ → tier3/ (semantic)
+    const parametricDir = path.join(baseDir, 'parametric');
+    if (fs.existsSync(parametricDir)) {
+        const files = fs.readdirSync(parametricDir).filter(f => f.endsWith('.yml') || f.endsWith('.yaml'));
+        for (const file of files) {
+            try {
+                const content = fs.readFileSync(path.join(parametricDir, file), 'utf-8');
+                const unit = {
+                    id: (0, harmonic_types_1.generateHarmonicId)(),
+                    type: 'semantic',
+                    primary_abstraction: file.replace(/\.[^.]+$/, '').slice(0, 50),
+                    cue_anchors: extractAnchors(content),
+                    memory_value: content.slice(0, 1000),
+                    energy: 0.6,
+                    created_at: new Date().toISOString(),
+                    updated_at: new Date().toISOString()
+                };
+                const tier3File = path.join(memoryDir, 'tier3.json');
+                const existing = fs.existsSync(tier3File) ? JSON.parse(fs.readFileSync(tier3File, 'utf-8')) : [];
+                existing.push(unit);
+                fs.writeFileSync(tier3File, JSON.stringify(existing, null, 2), 'utf-8');
+                indexManager.addEntry(unit, 'tier3');
+                result.migrated++;
+            }
+            catch (err) {
+                result.errors.push(`parametric/${file}: ${err.message}`);
+            }
+        }
+    }
+    // Backup old directories
+    const backupDir = path.join(baseDir, '.backup-v61');
+    if (!fs.existsSync(backupDir))
+        fs.mkdirSync(backupDir, { recursive: true });
+    for (const oldDir of ['lessons', 'parametric']) {
+        const src = path.join(baseDir, oldDir);
+        if (fs.existsSync(src)) {
+            const dest = path.join(backupDir, oldDir);
+            if (!fs.existsSync(dest))
+                fs.renameSync(src, dest);
+        }
+    }
+    return result;
+}
+function extractAnchors(content) {
+    const anchors = new Set();
+    const patterns = [
+        /(jwt|oauth|bcrypt|auth)/gi, /(error|fail|exception)/gi,
+        /(coverage|test|jest)/gi, /(api|endpoint|route)/gi,
+        /(config|setting|env)/gi, /(async|await|promise)/gi
+    ];
+    for (const pattern of patterns) {
+        const matches = content.match(pattern);
+        if (matches)
+            matches.forEach(m => anchors.add(m.toLowerCase()));
+    }
+    return Array.from(anchors).slice(0, 8);
+}

package/gateway/dist/core/memory/minhash-merger.js

@@ -0,0 +1,195 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MinHashMerger = void 0;
+class MinHashMerger {
+    signatureSize = 32;
+    threshold = 0.7;
+    maxMergeChars = 500;
+    maxMergeDepth = 10;
+    maxMergedValueChars = 2000;
+    static normalizeForDedup(text) {
+        return text
+            .toLowerCase()
+            .replace(/[^\p{L}\p{N}\s]/gu, '')
+            .replace(/\s+/g, ' ')
+            .trim();
+    }
+    /** Split a (possibly merged) abstraction into its ' | ' segments. */
+    static segmentsOf(text) {
+        return text.split(' | ');
+    }
+    /** FNV-1a 32-bit. */
+    static hashForward(s) {
+        let h = 0x811c9dc5;
+        for (let i = 0; i < s.length; i++) {
+            h ^= s.charCodeAt(i);
+            h = Math.imul(h, 0x01000193);
+        }
+        return h >>> 0;
+    }
+    /** FNV-1a over the reversed string, forced odd (second independent hash). */
+    static hashReverse(s) {
+        let h = 0x811c9dc5;
+        for (let i = s.length - 1; i >= 0; i--) {
+            h ^= s.charCodeAt(i);
+            h = Math.imul(h, 0x01000193);
+        }
+        return (h | 1) >>> 0;
+    }
+    /**
+     * MinHash signature via double hashing (Kirsch–Mitzenmacher): two
+     * independent FNV-1a hashes per shingle generate signatureSize values
+     * h_k = (h1 + k*h2) mod 2^32. Replaces the old `hash*31 + charCode + seed`
+     * scheme whose in-loop seed was negligible next to char codepoints — all
+     * "independent" hashes degenerated to picking the same lowest-codepoint
+     * shingle, so any two memories sharing one English token (e.g. "gateway")
+     * scored similarity 1.0 and were wrongly merged.
+     */
+    generateSignature(text) {
+        const normalized = MinHashMerger.normalizeForDedup(text);
+        const sig = new Array(this.signatureSize).fill(Number.MAX_SAFE_INTEGER);
+        let found = false;
+        for (let i = 0; i + 3 <= normalized.length; i++) {
+            const shingle = normalized.slice(i, i + 3);
+            const h1 = MinHashMerger.hashForward(shingle);
+            const h2 = MinHashMerger.hashReverse(shingle);
+            found = true;
+            for (let k = 0; k < this.signatureSize; k++) {
+                const hk = (h1 + Math.imul(k, h2)) >>> 0;
+                if (hk < sig[k])
+                    sig[k] = hk;
+            }
+        }
+        return found ? sig : sig.fill(0);
+    }
+    similarity(sigA, sigB) {
+        let matches = 0;
+        for (let i = 0; i < this.signatureSize; i++) {
+            if (sigA[i] === sigB[i]) {
+                matches++;
+            }
+        }
+        return matches / this.signatureSize;
+    }
+    /**
+     * Max similarity of a signature against each ' | ' segment of a (possibly
+     * merged) text. Merged blobs concatenate segments, which dilutes whole-text
+     * Jaccard (a true duplicate of one segment scores ~1/segments against the
+     * blob); taking the per-segment max preserves duplicate detection.
+     */
+    maxSimilarityToText(sig, text) {
+        let best = 0;
+        for (const seg of MinHashMerger.segmentsOf(text)) {
+            const s = this.similarity(sig, this.generateSignature(seg));
+            if (s > best)
+                best = s;
+        }
+        return best;
+    }
+    /**
+     * Cross-tier merge check. `read` resolves an id to its unit; `deleteSync`
+     * removes an id WITHOUT going through a write queue (the caller must already
+     * be inside its serialized write path). If `markSuperseded` is provided, old
+     * entries are kept but marked as superseded and energetically demoted instead
+     * of being physically deleted — this preserves old facts for knowledge-update
+     * queries while letting newer versions outrank them. If `unit` already
+     * carries merged_from it is the product of an earlier merge — skip to avoid
+     * recursive loops.
+     */
+    async merge(unit, indexManager, store) {
+        if (unit.merged_from?.length)
+            return unit;
+        const normalizedNew = MinHashMerger.normalizeForDedup(unit.primary_abstraction);
+        if (normalizedNew.length < 3)
+            return unit;
+        const sig = this.generateSignature(unit.primary_abstraction);
+        const index = indexManager.getIndex();
+        const mergedFrom = [];
+        let result = { ...unit };
+        for (const entry of index.entries) {
+            if (entry.id === unit.id)
+                continue;
+            if (entry.superseded_by)
+                continue;
+            if ((entry.merged_from?.length ?? 0) >= this.maxMergeDepth)
+                continue;
+            const exactMatch = normalizedNew.length > 0
+                && MinHashMerger.segmentsOf(entry.primary_abstraction)
+                    .some(seg => MinHashMerger.normalizeForDedup(seg) === normalizedNew);
+            const sim = exactMatch ? 1.0 : this.maxSimilarityToText(sig, entry.primary_abstraction);
+            if (sim > this.threshold) {
+                const existingUnit = await store.read(entry.id);
+                if (!existingUnit)
+                    continue;
+                if (existingUnit.pinned)
+                    result.pinned = true;
+                // B4: don't grow beyond the length cap — a mega blob pollutes retrieval.
+                const combinedLen = (result.primary_abstraction?.length || 0) +
+                    (existingUnit.primary_abstraction?.length || 0);
+                if (combinedLen > this.maxMergeChars)
+                    continue;
+                result.primary_abstraction = this.dedupMerge(result.primary_abstraction, existingUnit.primary_abstraction);
+                result.cue_anchors = this.dedupAnchors([
+                    ...result.cue_anchors,
+                    ...existingUnit.cue_anchors,
+                ]);
+                result.memory_value = this.mergeValues(result.memory_value, existingUnit.memory_value, result.updated_at);
+                mergedFrom.push(existingUnit.id);
+                if (existingUnit.merged_from?.length) {
+                    for (const ancestorId of existingUnit.merged_from) {
+                        if (!mergedFrom.includes(ancestorId))
+                            mergedFrom.push(ancestorId);
+                    }
+                }
+                if (store.markSuperseded) {
+                    store.markSuperseded(existingUnit.id, unit.id);
+                }
+                else {
+                    store.deleteSync(existingUnit.id);
+                }
+            }
+        }
+        if (mergedFrom.length > 0) {
+            result.merged_from = [
+                ...(result.merged_from || []),
+                ...mergedFrom,
+            ];
+            result.updated_at = new Date().toISOString();
+        }
+        return result;
+    }
+    mergeValues(newerValue, olderValue, updatedAt) {
+        if (newerValue === olderValue)
+            return newerValue;
+        const header = updatedAt ? `[Updated ${updatedAt}] ` : '[Updated] ';
+        const sep = `\n---\n${header}`;
+        const budget = this.maxMergedValueChars - newerValue.length - sep.length;
+        if (budget <= 0)
+            return newerValue;
+        let kept = olderValue.length <= budget ? olderValue : olderValue.slice(0, budget);
+        if (kept.length < olderValue.length) {
+            // Cut at the last section boundary so we never leave a truncated section.
+            const lastBoundary = kept.lastIndexOf('\n---\n');
+            if (lastBoundary > 0)
+                kept = kept.slice(0, lastBoundary);
+        }
+        return `${newerValue}${sep}${kept}`;
+    }
+    dedupMerge(a, b) {
+        const normA = MinHashMerger.normalizeForDedup(a);
+        const normB = MinHashMerger.normalizeForDedup(b);
+        if (normA === normB)
+            return a;
+        // If a is already one of b's segments, keep b unchanged (prevents
+        // identical-duplicate writes from growing the blob with repeat segments).
+        for (const seg of MinHashMerger.segmentsOf(b)) {
+            if (MinHashMerger.normalizeForDedup(seg) === normA)
+                return b;
+        }
+        return `${a} | ${b}`;
+    }
+    dedupAnchors(anchors) {
+        return [...new Set(anchors)];
+    }
+}
+exports.MinHashMerger = MinHashMerger;