cogmem 3.6.2

package/dist/types/index.js

@@ -0,0 +1,24 @@
+// ============================================
+// 核心类型定义 - cogmem
+// ============================================
+export var ContextFusionPath;
+(function (ContextFusionPath) {
+    ContextFusionPath["COMPILED_ONLY"] = "compiled_only";
+    ContextFusionPath["RAW_ONLY"] = "raw_only";
+    ContextFusionPath["COMPILED_PLUS_RAW"] = "compiled_plus_raw";
+    ContextFusionPath["CONFLICT_RESOLVED"] = "conflict_resolved";
+})(ContextFusionPath || (ContextFusionPath = {}));
+export var FusionResolutionReason;
+(function (FusionResolutionReason) {
+    FusionResolutionReason["COMPILED_WINS"] = "compiled_wins";
+    FusionResolutionReason["RAW_WINS"] = "raw_wins";
+    FusionResolutionReason["TRUST_SCORE_HIGHER"] = "trust_score_higher";
+    FusionResolutionReason["RECENCY_WINS"] = "recency_wins";
+})(FusionResolutionReason || (FusionResolutionReason = {}));
+// -------------------- 降级模式 --------------------
+export var BrainMode;
+(function (BrainMode) {
+    BrainMode["FULL"] = "FULL";
+    BrainMode["NO_SYNAPSE"] = "NO_SYNAPSE";
+    BrainMode["TEXT_ONLY"] = "TEXT_ONLY";
+})(BrainMode || (BrainMode = {}));

package/dist/types/query-ir.d.ts

@@ -0,0 +1,71 @@
+export type IntentType = 'recall' | 'trace' | 'update';
+export interface TemporalConstraint {
+    start?: number;
+    end?: number;
+    relative?: 'today' | 'yesterday' | 'this_week' | 'this_month' | 'last_week' | 'last_month' | 'this_year' | 'last_year' | 'past_six_months' | 'past_year' | 'around_half_year_ago';
+}
+export interface SpatialConstraint {
+    projectId?: string;
+    filePath?: string;
+    fileType?: string;
+}
+export interface QuerySemanticHints {
+    subjectHint?: string;
+    predicateHint?: 'preference' | 'decision' | 'constraint' | 'fact' | 'workflow' | 'graph' | 'sequence' | 'plan';
+    entityHints: string[];
+    valueHints: string[];
+    conditionHints: string[];
+    environmentHints: string[];
+    stateHints: string[];
+    policyHints: string[];
+    guardHints: string[];
+    executorHints: string[];
+    validationHints: string[];
+    mergeHints: string[];
+    asksForHistory: boolean;
+}
+export interface NativeQueryDirectives {
+    entity?: string;
+    entityType?: string;
+    project?: string;
+    branch?: string;
+    task?: string;
+    cluster?: string;
+    time?: string;
+    from?: string;
+    to?: string;
+    around?: string;
+    mode?: 'continuous' | 'focused';
+}
+export interface NativeQueryAstClause {
+    type: 'directive' | 'term';
+    key?: keyof NativeQueryDirectives;
+    value: string;
+}
+export interface NativeQueryAstGroup {
+    kind: 'group';
+    operator: 'AND' | 'OR';
+    clauses: Array<NativeQueryAstClause | NativeQueryAstGroup>;
+}
+export interface NativeQueryDebugInfo {
+    parseMode: 'grammar';
+    residualQuery: string;
+    clauses: Array<{
+        key: keyof NativeQueryDirectives;
+        value: string;
+    }>;
+    ast?: NativeQueryAstGroup;
+}
+export interface QueryIR {
+    rawQuery: string;
+    entities: string[];
+    intentType: IntentType;
+    temporal: TemporalConstraint;
+    spatial: SpatialConstraint;
+    mustMatch: string[];
+    shouldMatch: string[];
+    semantics: QuerySemanticHints;
+    nativeDirectives?: NativeQueryDirectives;
+    nativeQueryDebug?: NativeQueryDebugInfo;
+}
+//# sourceMappingURL=query-ir.d.ts.map

package/dist/types/query-ir.js

@@ -0,0 +1,4 @@
+// ============================================
+// QueryIR - 查询意图中间表示
+// ============================================
+export {};

package/dist/types/reasoning.d.ts

@@ -0,0 +1,16 @@
+export type ReasoningStepRole = 'premise' | 'hypothesis' | 'evidence' | 'conclusion';
+export type SourceType = 'user_input' | 'llm_inference' | 'verified_fact';
+export type ReasoningOutcome = 'pending' | 'confirmed' | 'refuted' | 'inconclusive';
+export interface ReasoningStep {
+    neuronId: string;
+    role: ReasoningStepRole;
+    order: number;
+}
+export interface ReasoningChain {
+    id: string;
+    steps: ReasoningStep[];
+    outcome: ReasoningOutcome;
+    projectId?: string;
+    createdAt: number;
+}
+//# sourceMappingURL=reasoning.d.ts.map

package/dist/types/reasoning.js

@@ -0,0 +1,4 @@
+// ============================================
+// ReasoningChain - 推理链（程序性记忆）
+// ============================================
+export {};

package/dist/utils/AAAKGenerator.d.ts

@@ -0,0 +1,57 @@
+/**
+ * AAAK 格式转换规则：
+ * - | : 维度分隔符
+ * - : : 属性定义
+ * - > : 优选/比较
+ * - → : 因果/流转
+ * - () : 细节补充
+ * - ★ : 权重标记
+ */
+export declare class AAAKGenerator {
+    /**
+     * 生成 AAAK 格式摘要
+     * @param content 原始内容
+     * @param type 神经元类型（code/chat/doc/command）
+     * @param importance 重要性权重 1-5
+     */
+    generateSummary(content: string, type?: string, importance?: number): Promise<string>;
+    /**
+     * 同步生成 AAAK 格式摘要（用于事务）
+     */
+    generateSummarySync(content: string, type?: string, importance?: number): string;
+    /**
+     * 基于规则的 AAAK 压缩
+     */
+    private ruleBasedCompress;
+    /**
+     * 压缩代码类型内容
+     */
+    private compressCode;
+    /**
+     * 压缩对话类型内容
+     */
+    private compressChat;
+    /**
+     * 压缩文档类型内容
+     */
+    private compressDoc;
+    /**
+     * 压缩命令类型内容
+     */
+    private compressCommand;
+    /**
+     * 通用压缩
+     */
+    private compressGeneric;
+    /**
+     * 解析 AAAK 格式（反向操作）
+     */
+    parseAAAK(aaak: string): {
+        entities: string[];
+        decision?: string;
+        cause?: string;
+        importance: number;
+    };
+}
+export declare const aaakGenerator: AAAKGenerator;
+//# sourceMappingURL=AAAKGenerator.d.ts.map

package/dist/utils/AAAKGenerator.js

@@ -0,0 +1,212 @@
+// ============================================
+// AAAK (AI-to-AI Knowledge) 摘要生成器
+// ============================================
+import { logger } from '../utils/Logger.js';
+/**
+ * AAAK 格式转换规则：
+ * - | : 维度分隔符
+ * - : : 属性定义
+ * - > : 优选/比较
+ * - → : 因果/流转
+ * - () : 细节补充
+ * - ★ : 权重标记
+ */
+export class AAAKGenerator {
+    /**
+     * 生成 AAAK 格式摘要
+     * @param content 原始内容
+     * @param type 神经元类型（code/chat/doc/command）
+     * @param importance 重要性权重 1-5
+     */
+    async generateSummary(content, type = 'chat', importance = 3) {
+        try {
+            // 简单实现：基于规则提取关键信息
+            // 后续可以集成本地 LLM 进行更智能的摘要
+            const summary = this.ruleBasedCompress(content, type, importance);
+            logger.debug(`AAAK: generated summary (${summary.length} chars from ${content.length})`);
+            return summary;
+        }
+        catch (error) {
+            logger.error('AAAK generation failed:', error);
+            return content; // 回退到原始内容
+        }
+    }
+    /**
+     * 同步生成 AAAK 格式摘要（用于事务）
+     */
+    generateSummarySync(content, type = 'chat', importance = 3) {
+        return this.ruleBasedCompress(content, type, importance);
+    }
+    /**
+     * 基于规则的 AAAK 压缩
+     */
+    ruleBasedCompress(content, type, importance) {
+        const stars = '★'.repeat(importance);
+        switch (type) {
+            case 'code':
+                return this.compressCode(content, stars);
+            case 'chat':
+                return this.compressChat(content, stars);
+            case 'doc':
+                return this.compressDoc(content, stars);
+            case 'command':
+                return this.compressCommand(content, stars);
+            default:
+                return this.compressGeneric(content, stars);
+        }
+    }
+    /**
+     * 压缩代码类型内容
+     */
+    compressCode(content, stars) {
+        // 提取关键代码元素
+        const lines = content.split('\n').filter(l => l.trim().length > 0);
+        // 提取函数名、类名
+        const functions = content.match(/(?:function|const|let|class|def|async)\s+(\w+)/g) || [];
+        const imports = content.match(/import\s+.*?from\s+['"](.+?)['"]/g) || [];
+        let summary = '';
+        if (functions.length > 0) {
+            summary += 'FUNC:' + functions.slice(0, 5).join(', ');
+        }
+        if (imports.length > 0) {
+            if (summary)
+                summary += ' | ';
+            summary += 'IMP:' + imports.slice(0, 3).join(', ');
+        }
+        // 添加文件路径信息
+        if (content.includes('//') || content.includes('/*')) {
+            const comments = content.match(/\/\/(.+)$|\/\*(.+)\*\//g);
+            if (comments && comments.length > 0) {
+                if (summary)
+                    summary += ' | ';
+                summary += 'NOTE:' + comments[0].replace(/\/\/|\/\*|\*\//g, '').trim().slice(0, 50);
+            }
+        }
+        return summary ? `${summary} | ${stars}` : `${stars}`;
+    }
+    /**
+     * 压缩对话类型内容
+     */
+    compressChat(content, stars) {
+        // 提取关键信息
+        const lines = content.split('\n').filter(l => l.trim().length > 0);
+        // 提取人物
+        const users = content.match(/(?:^|\s)([A-Z][a-z]+(?:\s+[A-Z][a-z]+)?)(?=\s|$|:)/g) || [];
+        const userMatches = users.map(u => u.trim()).filter(u => u.length > 2).slice(0, 3);
+        // 提取决策关键词
+        const decisions = content.match(/(?:决定|决定|decision|decided|选择|choose|使用|using|采用|adopt)/gi) || [];
+        // 提取项目/技术关键词
+        const projects = content.match(/(?:PROJ|Project|项目)[:\s]+(\w+)/gi) || [];
+        const techs = content.match(/(?:使用|using|技术|tech)[:\s]+(\w+)/gi) || [];
+        let summary = '';
+        if (userMatches.length > 0) {
+            summary += 'USERS:' + userMatches.join(', ');
+        }
+        if (decisions.length > 0) {
+            if (summary)
+                summary += ' | ';
+            summary += 'DECISION:' + decisions[0];
+        }
+        if (projects.length > 0 || techs.length > 0) {
+            if (summary)
+                summary += ' | ';
+            summary += 'PROJ:' + (projects[0] || '') + ' TECH:' + (techs[0] || '');
+        }
+        // 提取因果关系
+        const causes = content.match(/(.+?)\s*(?:因为|due to|because|因此|therefore|导致|lead to)(.+)/gi) || [];
+        if (causes.length > 0) {
+            if (summary)
+                summary += ' | ';
+            summary += '→' + causes[0]?.slice(0, 50) || "";
+        }
+        return summary ? `${summary} | ${stars}` : `${stars}`;
+    }
+    /**
+     * 压缩文档类型内容
+     */
+    compressDoc(content, stars) {
+        // 提取标题
+        const titleMatch = content.match(/(?:^#?\s*(.+)$)/m);
+        const title = titleMatch ? titleMatch[1].trim().slice(0, 30) : '';
+        // 提取关键点
+        const bullets = content.match(/(?:^[-*]\s*(.+)$)/gm) || [];
+        const keyPoints = bullets.slice(0, 3).map(b => b.replace(/^[-*]\s*/, '').trim()).join('; ');
+        let summary = '';
+        if (title) {
+            summary += 'TITLE:' + title;
+        }
+        if (keyPoints) {
+            if (summary)
+                summary += ' | ';
+            summary += 'POINTS:' + keyPoints;
+        }
+        return summary ? `${summary} | ${stars}` : `${stars}`;
+    }
+    /**
+     * 压缩命令类型内容
+     */
+    compressCommand(content, stars) {
+        // 提取命令和参数
+        const cmdMatch = content.match(/(?:^\s*)(\$\s*\w+|\w+)(?:\s+(.+))?/m);
+        const cmd = cmdMatch ? cmdMatch[1].trim() : '';
+        const args = cmdMatch && cmdMatch[2] ? cmdMatch[2].trim().slice(0, 30) : '';
+        // 提取输出
+        const output = content.match(/(?:output|result)[:\s]*(.+)/i) || [];
+        let summary = '';
+        if (cmd) {
+            summary += 'CMD:' + cmd;
+        }
+        if (args) {
+            if (summary)
+                summary += ' | ';
+            summary += 'ARGS:' + args;
+        }
+        if (output.length > 0) {
+            if (summary)
+                summary += ' | ';
+            summary += 'OUT:' + output[0]?.slice(0, 30) || "";
+        }
+        return summary ? `${summary} | ${stars}` : `${stars}`;
+    }
+    /**
+     * 通用压缩
+     */
+    compressGeneric(content, stars) {
+        // 取前 100 个字符作为摘要
+        const truncated = content.slice(0, 100).replace(/\n/g, ' ').trim();
+        return `CONTENT:${truncated}... | ${stars}`;
+    }
+    /**
+     * 解析 AAAK 格式（反向操作）
+     */
+    parseAAAK(aaak) {
+        const entities = [];
+        let decision;
+        let cause;
+        let importance = 3;
+        // 提取星级
+        const starMatch = aaak.match(/★+/);
+        if (starMatch) {
+            importance = starMatch[0].length;
+        }
+        // 提取实体
+        const entityMatches = aaak.match(/(?:USERS|PROJ|TECH|FUNC|IMP)[:]([^|]+)/g) || [];
+        for (const match of entityMatches) {
+            const [, value] = match.split(':');
+            if (value)
+                entities.push(value.trim());
+        }
+        // 提取决策
+        const decisionMatch = aaak.match(/DECISION[:]([^|]+)/);
+        if (decisionMatch) {
+            decision = decisionMatch[1].trim();
+        }
+        // 提取因果
+        const causeMatch = aaak.match(/→(.+?)(?:$|\|)/);
+        if (causeMatch) {
+            cause = causeMatch[1].trim();
+        }
+        return { entities, decision, cause, importance };
+    }
+}
+export const aaakGenerator = new AAAKGenerator();

package/dist/utils/Config.d.ts

@@ -0,0 +1,78 @@
+import type { EmbeddingConfig } from '../types/index.js';
+export interface AgentBrainConfig {
+    vector: {
+        dimension: number;
+        maxElements: number;
+        efConstruction: number;
+        efSearch: number;
+        topK: number;
+        indexPath: string;
+    };
+    embedding: EmbeddingConfig;
+    energy: {
+        initialEnergy: number;
+        decayFactor: number;
+        maxHops: number;
+    };
+    degradation: {
+        memoryThresholdMB: number;
+        slowInferenceThresholdMs: number;
+    };
+    index: {
+        anchorInterval: number;
+        fullTextSearchLimit: number;
+    };
+    logging: {
+        level: 'debug' | 'info' | 'warn' | 'error';
+        enabled: boolean;
+    };
+    recall: {
+        /** Trigger vector fallback when candidateNeuronIds.length < this. Default 12. */
+        vectorFallbackThreshold: number;
+        /** Master switch for vector semantic search. Default true. */
+        vectorEnabled: boolean;
+    };
+}
+declare class Config {
+    private config;
+    constructor(overrides?: Partial<AgentBrainConfig>);
+    private merge;
+    get(key?: string): unknown;
+    set(key: string, value: unknown): void;
+    get vector(): {
+        dimension: number;
+        maxElements: number;
+        efConstruction: number;
+        efSearch: number;
+        topK: number;
+        indexPath: string;
+    };
+    get embedding(): EmbeddingConfig;
+    get energy(): {
+        initialEnergy: number;
+        decayFactor: number;
+        maxHops: number;
+    };
+    get degradation(): {
+        memoryThresholdMB: number;
+        slowInferenceThresholdMs: number;
+    };
+    get index(): {
+        anchorInterval: number;
+        fullTextSearchLimit: number;
+    };
+    get logging(): {
+        level: "debug" | "info" | "warn" | "error";
+        enabled: boolean;
+    };
+    get recall(): {
+        /** Trigger vector fallback when candidateNeuronIds.length < this. Default 12. */
+        vectorFallbackThreshold: number;
+        /** Master switch for vector semantic search. Default true. */
+        vectorEnabled: boolean;
+    };
+    static default(): AgentBrainConfig;
+}
+export declare const config: Config;
+export { Config as ConfigClass };
+//# sourceMappingURL=Config.d.ts.map

package/dist/utils/Config.js

@@ -0,0 +1,91 @@
+// ============================================
+// 配置管理 - 统一管理所有配置
+// ============================================
+import { DEFAULT_VECTOR_DIMENSION } from '../config/VectorDimension.js';
+const DEFAULT_CONFIG = {
+    vector: {
+        dimension: DEFAULT_VECTOR_DIMENSION,
+        maxElements: 1000000,
+        efConstruction: 200,
+        efSearch: 50,
+        topK: 500,
+        indexPath: './data/hnsw.index'
+    },
+    embedding: {
+        model: 'all-MiniLM-L6-v2',
+        cacheDir: `${process.env.HOME || '/tmp'}/.cache/cogmem/embeddings`,
+        quantized: true,
+        maxSequenceLength: 512
+    },
+    energy: {
+        initialEnergy: 100,
+        decayFactor: 0.8,
+        maxHops: 5
+    },
+    degradation: {
+        memoryThresholdMB: 1024,
+        slowInferenceThresholdMs: 150
+    },
+    index: {
+        anchorInterval: 500,
+        fullTextSearchLimit: 100
+    },
+    logging: {
+        level: 'info',
+        enabled: true
+    },
+    recall: {
+        vectorFallbackThreshold: 12,
+        vectorEnabled: true
+    }
+};
+class Config {
+    config;
+    constructor(overrides = {}) {
+        this.config = this.merge(DEFAULT_CONFIG, overrides);
+    }
+    merge(base, overrides) {
+        const result = { ...base };
+        const overrideKeys = Object.keys(overrides);
+        for (const key of overrideKeys) {
+            const value = overrides[key];
+            if (value && typeof value === 'object' && !Array.isArray(value)) {
+                result[key] = this.merge((base[key] || {}), value);
+            }
+            else {
+                result[key] = value;
+            }
+        }
+        return result;
+    }
+    get(key) {
+        if (!key)
+            return this.config;
+        const keys = key.split('.');
+        let value = this.config;
+        for (const k of keys) {
+            value = value?.[k];
+        }
+        return value;
+    }
+    set(key, value) {
+        const keys = key.split('.');
+        let obj = this.config;
+        for (let i = 0; i < keys.length - 1; i++) {
+            obj = obj[keys[i]];
+        }
+        obj[keys[keys.length - 1]] = value;
+    }
+    get vector() { return this.config.vector; }
+    get embedding() { return this.config.embedding; }
+    get energy() { return this.config.energy; }
+    get degradation() { return this.config.degradation; }
+    get index() { return this.config.index; }
+    get logging() { return this.config.logging; }
+    get recall() { return this.config.recall; }
+    static default() {
+        return { ...DEFAULT_CONFIG };
+    }
+}
+export const config = new Config();
+export { Config as ConfigClass };

package/dist/utils/ConversationMarkdownNormalization.d.ts

@@ -0,0 +1,88 @@
+export type NormalizationFamily = 'jsonl_transcript_export' | 'json_array_transcript_export' | 'csv_transcript_export' | 'tsv_transcript_export' | 'app_private_mixed_event_export' | 'jsonl_mixed_event_log_export';
+export type NormalizedSourceFamily = 'normalized_conversation_markdown';
+export interface NormalizationMetadata {
+    isNormalized: boolean;
+    contractVersion?: 'v1';
+    normalizedSourceFamily?: NormalizedSourceFamily;
+    originalInputFamily?: NormalizationFamily;
+    title?: string;
+    onboardingPath?: string;
+}
+export interface NormalizerArgs {
+    input?: string;
+    output?: string;
+    title: string;
+    format?: 'csv' | 'tsv';
+}
+export interface NormalizedMessage {
+    role: 'user' | 'agent' | 'system' | 'narrator';
+    text: string;
+    timestamp: string;
+    source?: NormalizedMessageSource;
+}
+export interface NormalizedMessageSource {
+    sourceOffset: number;
+    lineStart?: number;
+    lineEnd?: number;
+    charStart?: number;
+    charEnd?: number;
+    orderingConfidence?: 'high' | 'medium' | 'low';
+}
+export interface CustomNormalizerOptions<TRecord> {
+    family: NormalizationFamily;
+    mapRecord: (record: TRecord, index: number) => NormalizedMessage | NormalizedMessage[] | null | undefined;
+}
+export interface ExportBridgeMarker {
+    key: string;
+    value: string;
+}
+export interface ExportBridgeContext<TRecord, TRoot = unknown> {
+    index: number;
+    record: TRecord;
+    root: TRoot;
+    inputFamily: NormalizationFamily;
+}
+export interface ExportBridgeRecipe<TRecord, TRoot = unknown> {
+    inputFamily: NormalizationFamily;
+    selectRecords?: (input: TRoot) => TRecord[];
+    isMessageCandidate?: (record: TRecord, context: ExportBridgeContext<TRecord, TRoot>) => boolean;
+    mapRole: (record: TRecord, context: ExportBridgeContext<TRecord, TRoot>) => string | undefined;
+    extractText: (record: TRecord, context: ExportBridgeContext<TRecord, TRoot>) => string | undefined;
+    resolveTimestamp: (record: TRecord, context: ExportBridgeContext<TRecord, TRoot>) => string;
+    emitMarkers?: (record: TRecord, context: ExportBridgeContext<TRecord, TRoot>) => ExportBridgeMarker[] | undefined;
+}
+export interface ExportBridge<TRecord, TRoot = unknown> {
+    readonly inputFamily: NormalizationFamily;
+    normalizeRoot: (input: TRoot) => NormalizedMessage[];
+    normalizeRecords: (records: TRecord[], root?: TRoot) => NormalizedMessage[];
+    collectMarkers: (records: TRecord[], root?: TRoot) => ExportBridgeMarker[];
+    collectRootMarkers: (input: TRoot) => ExportBridgeMarker[];
+}
+export interface BridgeNormalizationResult {
+    family: NormalizationFamily;
+    messages: NormalizedMessage[];
+    markers: ExportBridgeMarker[];
+}
+type LooseRecord = Record<string, unknown>;
+export declare function parseNormalizerArgs(argv: string[], usage: string): NormalizerArgs;
+export declare function normalizeRole(input: string | undefined): 'user' | 'agent' | 'system' | 'narrator';
+export declare function pickMessageText(item: LooseRecord): string;
+export declare function pickTimestamp(item: LooseRecord, fallback: number): string;
+export declare function writeNormalizedConversationMarkdown(outputPath: string, title: string, family: NormalizationFamily, messages: NormalizedMessage[], markers?: ExportBridgeMarker[]): void;
+export declare function normalizeJsonlRecords(inputPath: string): NormalizedMessage[];
+export declare function normalizeJsonArrayRecords(inputPath: string): NormalizedMessage[];
+export declare function normalizeDelimitedRecords(inputPath: string, format?: 'csv' | 'tsv'): {
+    family: NormalizationFamily;
+    messages: NormalizedMessage[];
+};
+export declare function detectNormalizationFamily(markdown: string): NormalizationFamily | undefined;
+export declare function parseNormalizationMetadata(markdown: string): NormalizationMetadata;
+export declare function createConversationMarkdownNormalizer<TRecord>(options: CustomNormalizerOptions<TRecord>): (records: TRecord[]) => NormalizedMessage[];
+export declare function normalizeAppPrivateMixedEventRecords(inputPath: string): NormalizedMessage[];
+export declare function normalizeAppPrivateMixedEventExport(inputPath: string): BridgeNormalizationResult;
+export declare function normalizeJsonlMixedEventLogRecords(inputPath: string): NormalizedMessage[];
+export declare function normalizeJsonlMixedEventLogExport(inputPath: string): BridgeNormalizationResult;
+export declare function createExportBridge<TRecord, TRoot = TRecord[]>(recipe: ExportBridgeRecipe<TRecord, TRoot>): ExportBridge<TRecord, TRoot>;
+export declare function normalizeEventExportToConversationMarkdown<TRecord, TRoot = TRecord[]>(input: TRoot, bridge: ExportBridge<TRecord, TRoot>): BridgeNormalizationResult;
+export {};
+//# sourceMappingURL=ConversationMarkdownNormalization.d.ts.map