dsh-config-manager 0.1.76 → 0.1.77

package/lib/core/messages.d.ts

@@ -177,6 +177,7 @@ export declare const zh: {
     readonly 'host.sessionStoreShapeUnknown': '宿主会话存储列举（sessionPersistence.list()）的元素形状无法解析（探测形状 {shape}，{count} 个元素全部认不出）：父子关系判定放弃，绝不当作「本机没有父子关系」（请升级 DSH，或把该形状反馈给插件）';
     readonly 'host.sessionStorePurposeReindex': '会话 header 重新索引';
     readonly 'host.sessionStorePurposeParentRelations': '父子关系判定';
+    readonly 'host.sessionStorePurposeRewindAttach': '回退子会话归位';
     readonly 'host.sessionStoreListFailed': '会话存储列举失败（{purpose}）：{reason}';
     readonly 'host.sessionStoreListNotArray': '会话存储列举返回非数组（{purpose}）：形状未知，按不可用处理';
     readonly 'host.sessionStorePartialUnresolved': '会话存储列举中有 {count}/{total} 个元素形状无法解析（{purpose}）：已解析的照常使用';

package/lib/core/messages.js

@@ -166,6 +166,7 @@ export const zh = {
     'host.sessionStoreShapeUnknown': '宿主会话存储列举（sessionPersistence.list()）的元素形状无法解析（探测形状 {shape}，{count} 个元素全部认不出）：父子关系判定放弃，绝不当作「本机没有父子关系」（请升级 DSH，或把该形状反馈给插件）',
     'host.sessionStorePurposeReindex': '会话 header 重新索引',
     'host.sessionStorePurposeParentRelations': '父子关系判定',
+    'host.sessionStorePurposeRewindAttach': '回退子会话归位',
     'host.sessionStoreListFailed': '会话存储列举失败（{purpose}）：{reason}',
     'host.sessionStoreListNotArray': '会话存储列举返回非数组（{purpose}）：形状未知，按不可用处理',
     'host.sessionStorePartialUnresolved': '会话存储列举中有 {count}/{total} 个元素形状无法解析（{purpose}）：已解析的照常使用',
@@ -603,6 +604,7 @@ export const en = {
     'host.sessionStoreShapeUnknown': 'Cannot parse the elements returned by the host session store (sessionPersistence.list(); probed shape {shape}, none of the {count} elements is recognizable): parent/child detection is abandoned rather than treated as "no parent relations on this machine" (please upgrade DSH or report this shape to the plugin)',
     'host.sessionStorePurposeReindex': 'session header re-index',
     'host.sessionStorePurposeParentRelations': 'parent/child detection',
+    'host.sessionStorePurposeRewindAttach': 'rewind child session placement',
     'host.sessionStoreListFailed': 'Session store listing failed ({purpose}): {reason}',
     'host.sessionStoreListNotArray': 'Session store listing returned a non-array ({purpose}): unknown shape, treated as unavailable',
     'host.sessionStorePartialUnresolved': 'Session store listing: {count}/{total} elements have an unrecognized shape ({purpose}); the parsed ones are still used',

package/lib/core/rollback-attribution.d.ts

@@ -0,0 +1,81 @@
+/** 台账文件名（与回滚点库同目录：dataDir/rollback-points/attribution.json） */
+export declare const ROLLBACK_ATTRIBUTION_FILE_NAME = "attribution.json";
+/** 条目上限（超出按 at 淘汰最旧）—— 台账无界增长会把宿主拖垮（见 issue #89 的教训） */
+export declare const ROLLBACK_ATTRIBUTION_MAX_ENTRIES = 20000;
+/**
+ * 认得的**写类**工具名。
+ *
+ * 为什么用白名单而不是「参数里有 path 就算写」：`read` / `grep` / `ops_inspect_local_file`
+ * 的参数里也有 path —— 把它们当写入者会让**读**污染归属，进而让回退误跳过本该恢复的文件。
+ */
+export declare const ROLLBACK_WRITE_TOOL_NAMES: readonly string[];
+/** 一条写入归属：谁（会话）在什么时候用哪个工具写了这个路径 */
+export interface RollbackWriteFact {
+    sessionId: string;
+    tool: string;
+    callId: string;
+    /** 毫秒时间戳（本进程时钟） */
+    at: number;
+    turn: number | null;
+}
+/** 引擎只读这一面 */
+export interface RollbackWriteAttributionPort {
+    /** 该路径最后一次的写入归属；undefined = **未判定**（不是「没人写过」） */
+    writerOf(target: string): RollbackWriteFact | undefined;
+}
+/** 采集面（只有留点器的 noteEvent 用得上） */
+export interface RollbackWriteRecorder {
+    /**
+     * 记一次 `tool/call` 事件载荷。返回**记录到的路径条数**：
+     * 0 = 不是写类工具 / 解析不出路径 = **未判定**（绝不代表「没写过」）。
+     */
+    noteToolCall(sessionId: string, data: unknown): number;
+}
+/**
+ * 从一次 `tool/call` 事件载荷里抽出**会被写的路径**。
+ *
+ * `arguments` 在 DSH 的事件里是 **JSON 字符串**（不是对象）——两种形态都收，
+ * 解不出来就返回空数组（= 未判定），绝不抛错。
+ */
+export declare function toolCallWritePaths(name: unknown, argumentsValue: unknown): string[];
+export interface RollbackWriteAttributionOptions {
+    /** 台账文件绝对路径 */
+    file: string;
+    now?: () => number;
+    maxEntries?: number;
+    /** 落盘延迟（毫秒）；<= 0 表示不自动落盘（测试用） */
+    flushDelayMs?: number;
+    warn?: (line: string) => void;
+}
+/**
+ * 内存台账 + best-effort 落盘。
+ *
+ * 落盘的作用只有一个：**进程重启后**打开旧会话回退时，归属还在。
+ * 因此写入是延迟合并的（一次 tool/call 一行，立即落盘会把 I/O 打成筛子）。
+ */
+export declare class RollbackWriteAttribution implements RollbackWriteAttributionPort, RollbackWriteRecorder {
+    private readonly entries;
+    private readonly file;
+    private readonly now;
+    private readonly maxEntries;
+    private readonly flushDelayMs;
+    private readonly warn;
+    private loadPromise;
+    private flushTimer;
+    private writing;
+    constructor(options: RollbackWriteAttributionOptions);
+    /** 台账条目数（测试与诊断用） */
+    get size(): number;
+    /** 惰性读盘（幂等；读失败 = 空表，只 warn） */
+    load(): Promise<void>;
+    private read;
+    /** 记一次 tool/call（返回记录到的路径条数；0 = 不是写类工具或解析不出路径 = 未判定） */
+    noteToolCall(sessionId: string, data: unknown): number;
+    /** 淘汰最旧条目（按 at 升序删到上限内） */
+    private evictOldest;
+    writerOf(target: string): RollbackWriteFact | undefined;
+    /** 延迟落盘（多次调用只落一次） */
+    scheduleFlush(): void;
+    /** 立刻落盘（原子：同目录临时文件 + rename；失败只 warn，绝不上抛） */
+    flush(): Promise<void>;
+}

package/lib/core/rollback-attribution.js

@@ -0,0 +1,236 @@
+/**
+ * 工具调用的**写入归属台账** —— 「这个路径最后一次是哪个会话的哪次工具调用写的」。
+ *
+ * 为什么需要（2026-10-17 用户反馈）：回滚点的「工作区态」是**整个工作区**的快照，
+ * 回退也按整棵树执行 ⇒ 同一工作区里对话 A 改了文件，对话 B 回退时会把 A 的改动一起撤销。
+ * 有了归属，引擎才能在预览里标出「这个文件在留点之后是**别的**会话写的」，
+ * 让界面把它默认排除（用户仍可手动勾回来）。
+ *
+ * 三条不变量（不得放宽）：
+ *  ① 采集**尽力而为**：只有能解析出路径的写类工具（write/edit/ops_replace…）才记。
+ *     `pwsh` / `run_code` / 外部编辑器写的文件**没有归属** ⇒ 查不到 = **未判定**。
+ *  ② **未判定 ≠ 别的会话写的**：只有确知最后写入者是别的会话时才敢标 foreign。
+ *     拿不准就按老口径（照常恢复）—— 少标一次，比误判一次安全。
+ *  ③ 落盘失败只 warn：台账丢了只让归属退化成「未判定」，绝不参与留点 / 回退的成败判定。
+ */
+import fs from 'node:fs/promises';
+import path from 'node:path';
+/** 台账文件名（与回滚点库同目录：dataDir/rollback-points/attribution.json） */
+export const ROLLBACK_ATTRIBUTION_FILE_NAME = 'attribution.json';
+/** 条目上限（超出按 at 淘汰最旧）—— 台账无界增长会把宿主拖垮（见 issue #89 的教训） */
+export const ROLLBACK_ATTRIBUTION_MAX_ENTRIES = 20000;
+/**
+ * 认得的**写类**工具名。
+ *
+ * 为什么用白名单而不是「参数里有 path 就算写」：`read` / `grep` / `ops_inspect_local_file`
+ * 的参数里也有 path —— 把它们当写入者会让**读**污染归属，进而让回退误跳过本该恢复的文件。
+ */
+export const ROLLBACK_WRITE_TOOL_NAMES = [
+    'write',
+    'edit',
+    'ops_replace',
+    'ops_edit',
+    'write_file',
+    'str_replace',
+    'multi_edit',
+    'apply_patch',
+];
+/** 写类工具里代表「目标路径」的参数名（DSH 官方 write/edit 用 file_path；本插件工具用 path） */
+const WRITE_PATH_ARG_KEYS = ['file_path', 'path', 'filePath'];
+/** 路径比较键（与 `rollback-point.ts` 的 pathKey 同一口径：resolve + win32 折叠大小写） */
+function attributionPathKey(value) {
+    const resolved = path.resolve(value);
+    return process.platform === 'win32' ? resolved.toLowerCase() : resolved;
+}
+/**
+ * 从一次 `tool/call` 事件载荷里抽出**会被写的路径**。
+ *
+ * `arguments` 在 DSH 的事件里是 **JSON 字符串**（不是对象）——两种形态都收，
+ * 解不出来就返回空数组（= 未判定），绝不抛错。
+ */
+export function toolCallWritePaths(name, argumentsValue) {
+    if (typeof name !== 'string' || !ROLLBACK_WRITE_TOOL_NAMES.includes(name))
+        return [];
+    let parsed = argumentsValue;
+    if (typeof argumentsValue === 'string') {
+        try {
+            parsed = JSON.parse(argumentsValue);
+        }
+        catch {
+            return [];
+        }
+    }
+    if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed))
+        return [];
+    const record = parsed;
+    const out = [];
+    for (const key of WRITE_PATH_ARG_KEYS) {
+        const value = record[key];
+        if (typeof value === 'string' && value.trim() !== '')
+            out.push(value);
+    }
+    // 同一个调用里两个键指向同一路径是常见的（别名）⇒ 去重，避免同一路径记两次
+    return [...new Set(out)];
+}
+function readFact(value) {
+    if (value === null || typeof value !== 'object' || Array.isArray(value))
+        return null;
+    const record = value;
+    const sessionId = record.sessionId;
+    const at = record.at;
+    if (typeof sessionId !== 'string' || sessionId === '')
+        return null;
+    if (typeof at !== 'number' || !Number.isFinite(at))
+        return null;
+    return {
+        sessionId,
+        at,
+        tool: typeof record.tool === 'string' ? record.tool : '',
+        callId: typeof record.callId === 'string' ? record.callId : '',
+        turn: typeof record.turn === 'number' && Number.isFinite(record.turn) ? record.turn : null,
+    };
+}
+/**
+ * 内存台账 + best-effort 落盘。
+ *
+ * 落盘的作用只有一个：**进程重启后**打开旧会话回退时，归属还在。
+ * 因此写入是延迟合并的（一次 tool/call 一行，立即落盘会把 I/O 打成筛子）。
+ */
+export class RollbackWriteAttribution {
+    entries = new Map();
+    file;
+    now;
+    maxEntries;
+    flushDelayMs;
+    warn;
+    loadPromise = null;
+    flushTimer = null;
+    writing = null;
+    constructor(options) {
+        this.file = path.resolve(options.file);
+        this.now = options.now ?? (() => Date.now());
+        this.maxEntries = Math.max(1, options.maxEntries ?? ROLLBACK_ATTRIBUTION_MAX_ENTRIES);
+        this.flushDelayMs = options.flushDelayMs ?? 1000;
+        this.warn = options.warn ?? (() => { });
+    }
+    /** 台账条目数（测试与诊断用） */
+    get size() {
+        return this.entries.size;
+    }
+    /** 惰性读盘（幂等；读失败 = 空表，只 warn） */
+    async load() {
+        if (this.loadPromise === null)
+            this.loadPromise = this.read();
+        return this.loadPromise;
+    }
+    async read() {
+        try {
+            const text = await fs.readFile(this.file, 'utf8');
+            const parsed = JSON.parse(text);
+            if (parsed.version !== 1 || parsed.entries === null || typeof parsed.entries !== 'object' || Array.isArray(parsed.entries)) {
+                this.warn('rollback attribution ignored (shape): ' + this.file);
+                return;
+            }
+            for (const [key, value] of Object.entries(parsed.entries)) {
+                const fact = readFact(value);
+                // 读盘期间可能已经有本进程新记的条目 ⇒ **新记录优先**（磁盘只是旧快照）
+                if (fact !== null && !this.entries.has(key))
+                    this.entries.set(key, fact);
+            }
+        }
+        catch (error) {
+            const code = error.code;
+            // ENOENT = 还没写过台账（正常）；其它错误如实留痕但不抛
+            if (code !== 'ENOENT')
+                this.warn('rollback attribution unreadable: ' + this.file + ' ' + String(code ?? error));
+        }
+    }
+    /** 记一次 tool/call（返回记录到的路径条数；0 = 不是写类工具或解析不出路径 = 未判定） */
+    noteToolCall(sessionId, data) {
+        if (typeof sessionId !== 'string' || sessionId === '')
+            return 0;
+        if (data === null || typeof data !== 'object')
+            return 0;
+        const record = data;
+        const paths = toolCallWritePaths(record.name, record.arguments);
+        if (paths.length === 0)
+            return 0;
+        const fact = {
+            sessionId,
+            tool: typeof record.name === 'string' ? record.name : '',
+            callId: typeof record.callId === 'string' ? record.callId : '',
+            at: this.now(),
+            turn: typeof record.turn === 'number' && Number.isFinite(record.turn) ? record.turn : null,
+        };
+        for (const target of paths)
+            this.entries.set(attributionPathKey(target), fact);
+        if (this.entries.size > this.maxEntries)
+            this.evictOldest();
+        this.scheduleFlush();
+        return paths.length;
+    }
+    /** 淘汰最旧条目（按 at 升序删到上限内） */
+    evictOldest() {
+        const sorted = [...this.entries.entries()].sort((a, b) => a[1].at - b[1].at);
+        const over = this.entries.size - this.maxEntries;
+        for (let i = 0; i < over; i += 1) {
+            const item = sorted[i];
+            if (item !== undefined)
+                this.entries.delete(item[0]);
+        }
+    }
+    writerOf(target) {
+        return this.entries.get(attributionPathKey(target));
+    }
+    /** 延迟落盘（多次调用只落一次） */
+    scheduleFlush() {
+        if (this.flushDelayMs <= 0 || this.flushTimer !== null)
+            return;
+        this.flushTimer = setTimeout(() => {
+            this.flushTimer = null;
+            void this.flush();
+        }, this.flushDelayMs);
+        this.flushTimer.unref?.();
+    }
+    /** 立刻落盘（原子：同目录临时文件 + rename；失败只 warn，绝不上抛） */
+    async flush() {
+        if (this.writing !== null)
+            return this.writing;
+        this.writing = (async () => {
+            try {
+                await fs.mkdir(path.dirname(this.file), { recursive: true });
+                const entriesSnapshot = Object.fromEntries(this.entries);
+                // **写前合并**（2026-10-17 修）：本进程内存里只有自己见过的写入，而同一个工作区可能同时被
+                // 另一个 DSH 进程写归属 —— 各自「整体覆盖」会把对方的记录抹掉。真机实测：归属里缺了对方
+                // 那次编辑，导致回退时识别不到「别人改过这个文件」，进而把对方的改动静默覆盖掉。
+                // 同键取 `at` 较新者：时间戳是这里唯一可信的先后判据。
+                try {
+                    const existing = JSON.parse(await fs.readFile(this.file, 'utf8'));
+                    if (existing.version === 1 && existing.entries !== null && typeof existing.entries === 'object' && !Array.isArray(existing.entries)) {
+                        for (const [key, value] of Object.entries(existing.entries)) {
+                            const fact = readFact(value);
+                            if (fact === null)
+                                continue;
+                            const mine = entriesSnapshot[key];
+                            if (mine === undefined || fact.at > mine.at)
+                                entriesSnapshot[key] = fact;
+                        }
+                    }
+                }
+                catch { /* 读不到就当没有别人的记录：只写自己这份（绝不因为读失败而放弃落盘） */ }
+                const payload = { version: 1, entries: entriesSnapshot };
+                const tmp = this.file + '.tmp';
+                await fs.writeFile(tmp, JSON.stringify(payload), 'utf8');
+                await fs.rename(tmp, this.file);
+            }
+            catch (error) {
+                this.warn('rollback attribution write failed: ' + this.file + ' ' + String(error.code ?? error));
+            }
+            finally {
+                this.writing = null;
+            }
+        })();
+        return this.writing;
+    }
+}
+//# sourceMappingURL=rollback-attribution.js.map

package/lib/core/rollback-merge.d.ts

@@ -0,0 +1,22 @@
+/** 合并结论（`ok:false` 时调用方必须**零写入**） */
+export type ThreeWayMergeReason = 'clean' | 'conflict' | 'degraded' | 'binary';
+export interface ThreeWayMergeResult {
+    /** true = 结果可直接写入；false = 必须放弃写入并如实报告 */
+    ok: boolean;
+    /** 合并结果（`ok:false` 时是 theirs 原文 —— 方便调用方做「保持现状」的比较，绝不写入） */
+    text: string;
+    reason: ThreeWayMergeReason;
+    /** 冲突块数（>0 ⇒ ok=false） */
+    conflicts: number;
+    /** 本次合并**撤销**的行数（base 有、ours 没有）与**保留**的对方新增行数（诊断用） */
+    revertedLines: number;
+    /** 依赖风险提示（启发式；空数组 = 未发现明显风险，**不代表安全**） */
+    risks: string[];
+}
+/**
+ * 三方合并（纯函数、无 I/O）。
+ *
+ * 语义：结果是 `ours` 上再应用 `(theirs - base)` —— 撤销「我们从 base 改到 ours 的那部分」，
+ * 同时保留「别人从 base 改到 theirs 的那部分」。
+ */
+export declare function mergeThreeWay(ours: string, base: string, theirs: string): ThreeWayMergeResult;

package/lib/core/rollback-merge.js

@@ -0,0 +1,203 @@
+/**
+ * 行级**三方合并**（base / ours / theirs）—— 回退时「撤销本会话的改动、保留别人的改动」的判定内核。
+ *
+ * 为什么需要它（2026-10-17 跨对话安全回退）：
+ *  回滚点的「工作区态」是整棵树的快照，回退若直接整文件覆盖，会把别的对话在留点之后
+ *  产生的修改一起抹掉。正确语义是：把 **base→ours**（本会话那次改动的反向）与
+ *  **base→theirs**（别人后来的改动）同时应用到文件上 —— 即标准三方合并。
+ *
+ * 三方是谁（由调用方给定，本模块只管算）：
+ *  · `base`  = 共同祖先：本会话改动之后、别人的改动之前的那个版本；
+ *  · `ours`  = 回退目标：回滚点里记录的内容（= 本会话改之前的版本）；
+ *  · `theirs` = 当前磁盘上的内容。
+ *  结果为 `ours + (theirs - base)`，即撤销本会话、保留别人。
+ *
+ * 四条硬规矩：
+ *  ① **不确定就不合并**：任一方向的 diff 被规模预算降级（`degraded`）⇒ 直接拒绝（reason=`degraded`），
+ *     绝不拿一个「整块替换」的近似编辑脚本去算合并。
+ *  ② **冲突绝不自动选边**：两侧改到同一处（含同一插入点）就报冲突，返回 theirs 原文 + `ok:false`，
+ *     调用方必须**不写文件**并把冲突交给用户。
+ *  ③ **二进制不合并**（含 NUL 即二进制，与 git 同口径）。
+ *  ④ **依赖风险只提示、不假装证明**：合并要删掉的行里的标识符若仍出现在结果中，
+ *     给出**启发式**风险提示（`risks`）—— 它不构成「删除不安全」的证明，也绝不因此声称合并正确。
+ */
+import { diffLines, looksBinary } from '../utils/line-diff.js';
+/** 标识符取样用的最小长度（太短的词（i、id）同名词满天飞，只会制造噪声） */
+const RISK_TOKEN_MIN = 4;
+/** 不参与依赖提示的通用词（语言关键字 / 极常见标识符） */
+const RISK_STOPWORDS = new Set([
+    'const', 'let', 'var', 'function', 'return', 'import', 'export', 'from', 'class', 'interface', 'type',
+    'public', 'private', 'readonly', 'async', 'await', 'true', 'false', 'null', 'undefined', 'this', 'void',
+    'if', 'else', 'for', 'while', 'switch', 'case', 'break', 'continue', 'new', 'throw', 'try', 'catch',
+    'string', 'number', 'boolean', 'object', 'Array', 'Promise', 'Record', 'Partial', 'default',
+]);
+/**
+ * 一段文本相对 base 的**变更块**（按 base 的行区间表示）。
+ * 返回 null = 该方向的 diff 被降级（规模预算），调用方必须放弃合并。
+ */
+function changeBlocks(base, target) {
+    // context=0：只要变更行，块边界自己算（省得剔上下文）
+    const diff = diffLines(base, target, { context: 0 });
+    if (diff.degraded)
+        return null;
+    const blocks = [];
+    for (const hunk of diff.hunks) {
+        // 当前块与「已消耗到 base 的哪一行」
+        let block = null;
+        let cursor = Math.max(0, hunk.oldStart - 1);
+        const flush = () => {
+            if (block !== null)
+                blocks.push(block);
+            block = null;
+        };
+        for (const line of hunk.lines) {
+            if (line.kind === 'context') {
+                flush();
+                if (line.oldNo !== null)
+                    cursor = line.oldNo;
+                continue;
+            }
+            if (line.kind === 'del') {
+                const at = line.oldNo === null ? cursor : line.oldNo - 1;
+                if (block === null)
+                    block = { start: at, end: at, lines: [] };
+                block.end = at + 1;
+                cursor = at + 1;
+                continue;
+            }
+            // add：没有 del 时是纯插入（位置 = 当前游标）
+            if (block === null)
+                block = { start: cursor, end: cursor, lines: [] };
+            block.lines.push(line.text);
+        }
+        flush();
+    }
+    return blocks;
+}
+/** 两个块在 base 上是否**互相触碰**（保守：含边界与纯插入点） */
+function touches(a, b) {
+    const aPoint = a.start === a.end;
+    const bPoint = b.start === b.end;
+    if (aPoint && bPoint)
+        return a.start === b.start;
+    // **纯插入点落在区间端点不算冲突**：「删掉 `[s,e)`」与「在 e 处插入」可以共存（先删、再在删除后
+    // 的位置插入）。真机 2026-10-17 的「撤销 A 的描述 + 保留 B 的描述」正是这种形状：A 删掉了尾部
+    // 一行，B 又在其后追加了一行 —— 旧判据把它们当冲突，于是回退变成「什么都不做」。
+    // 只有落在区间**内部**（严格介于 s 与 e 之间）的插入才是真正说不清的冲突。
+    if (aPoint)
+        return a.start > b.start && a.start < b.end;
+    if (bPoint)
+        return b.start > a.start && b.start < a.end;
+    return a.start < b.end && b.start < a.end;
+}
+/** 两侧的块是否「改成了同一件事」（内容逐行相同即可取其一，不算冲突） */
+function sameChange(a, b) {
+    if (a.lines.length !== b.lines.length)
+        return false;
+    for (let i = 0; i < a.lines.length; i += 1)
+        if (a.lines[i] !== b.lines[i])
+            return false;
+    return true;
+}
+/** 从被撤销的行里取「可能仍被引用」的标识符（启发式，见模块头 ④） */
+function riskTokens(lines) {
+    const seen = new Set();
+    for (const line of lines) {
+        for (const token of line.match(/[A-Za-z_$][A-Za-z0-9_$]*/g) ?? []) {
+            if (token.length < RISK_TOKEN_MIN)
+                continue;
+            if (RISK_STOPWORDS.has(token))
+                continue;
+            seen.add(token);
+        }
+    }
+    return [...seen];
+}
+/**
+ * 三方合并（纯函数、无 I/O）。
+ *
+ * 语义：结果是 `ours` 上再应用 `(theirs - base)` —— 撤销「我们从 base 改到 ours 的那部分」，
+ * 同时保留「别人从 base 改到 theirs 的那部分」。
+ */
+export function mergeThreeWay(ours, base, theirs) {
+    const empty = (reason, conflicts = 0, risks = []) => ({
+        ok: false, text: theirs, reason, conflicts, revertedLines: 0, risks,
+    });
+    // 没有基线就退化成「谁的改动都不认识」—— 调用方负责在无 base 时根本不调用本函数
+    if (looksBinary(base) || looksBinary(ours) || looksBinary(theirs))
+        return empty('binary');
+    if (ours === base) {
+        // 本会话没改过 ⇒ 结论就是「保持别人现在的内容」（不是失败）
+        return { ok: true, text: theirs, reason: 'clean', conflicts: 0, revertedLines: 0, risks: [] };
+    }
+    if (theirs === base) {
+        // 别人没改过 ⇒ 直接回到 ours
+        return { ok: true, text: ours, reason: 'clean', conflicts: 0, revertedLines: 0, risks: [] };
+    }
+    if (ours === theirs) {
+        // 双方最终内容一致 ⇒ 谁都不用动
+        return { ok: true, text: theirs, reason: 'clean', conflicts: 0, revertedLines: 0, risks: [] };
+    }
+    const oursBlocks = changeBlocks(base, ours);
+    const theirsBlocks = changeBlocks(base, theirs);
+    if (oursBlocks === null || theirsBlocks === null)
+        return empty('degraded');
+    // 冲突扫描：任一 ours 块与任一 theirs 块触碰且内容不同 ⇒ 冲突
+    let conflicts = 0;
+    for (const a of oursBlocks) {
+        for (const b of theirsBlocks) {
+            if (!touches(a, b))
+                continue;
+            if (sameChange(a, b))
+                continue;
+            conflicts += 1;
+        }
+    }
+    if (conflicts > 0)
+        return empty('conflict', conflicts);
+    const baseLines = splitLinesOf(base);
+    const merged = [];
+    const reverted = [];
+    let cursor = 0;
+    // 把两侧的块按 base 位置归并（位置相同的「同一改动」只应用一次）
+    const all = [
+        ...oursBlocks.map((block) => ({ block, owner: 'ours' })),
+        ...theirsBlocks.map((block) => ({ block, owner: 'theirs' })),
+    ].sort((left, right) => left.block.start - right.block.start);
+    for (const item of all) {
+        const { block, owner } = item;
+        if (block.start < cursor) {
+            // 已被同一位置的另一个块消费（只可能是「同一改动」）—— 跳过重复应用
+            continue;
+        }
+        for (let i = cursor; i < block.start && i < baseLines.length; i += 1)
+            merged.push(baseLines[i]);
+        if (owner === 'ours') {
+            // 这一段就是「被撤销的本会话改动」：记下它删掉了哪些行，供依赖提示用
+            for (let i = block.start; i < block.end && i < baseLines.length; i += 1)
+                reverted.push(baseLines[i]);
+        }
+        for (const line of block.lines)
+            merged.push(line);
+        cursor = Math.max(cursor, block.end);
+    }
+    for (let i = cursor; i < baseLines.length; i += 1)
+        merged.push(baseLines[i]);
+    // 尾换行以**当前磁盘**（theirs）为准：我们是在它的基础上撤销本会话的改动，不擅改它原本的收尾形态
+    const text = merged.join('\n') + (merged.length > 0 && theirs.endsWith('\n') ? '\n' : '');
+    // 依赖风险（启发式）：被撤销的行里出现过、且合并结果里仍能读到的标识符
+    const tokens = riskTokens(reverted);
+    const risks = tokens.filter((token) => new RegExp('\\b' + token + '\\b').test(text)).slice(0, 8);
+    return { ok: true, text, reason: 'clean', conflicts: 0, revertedLines: reverted.length, risks };
+}
+/** 与 `splitLines` 同口径的本地折行（避免为了一个函数再引一层依赖） */
+function splitLinesOf(text) {
+    if (text === '')
+        return [];
+    const normalized = text.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
+    const lines = normalized.split('\n');
+    if (lines.length > 0 && lines[lines.length - 1] === '')
+        lines.pop();
+    return lines;
+}
+//# sourceMappingURL=rollback-merge.js.map