@lmzhen/dsh-evolution-merge 0.28.0 → 0.30.0

package/lib/types/doctor.js

@@ -0,0 +1,50 @@
+/**
+ * Merge doctor rows: state, pending, gate cache and staging are each probed read-only.
+ * A missing file is an empty feature, not a failure; an unreadable file is a warning the
+ * operator can act on. This module never repairs or writes.
+ */
+import { join } from 'node:path';
+import { probeList } from '@lmzhen/dsh-evolution-core';
+import { loadMergeState } from "./state.js";
+import { countRows } from "./status.js";
+import { stagingRoot } from "./staging.js";
+export const MERGE_DOCTOR_SCHEMA_VERSION = 3;
+export async function mergeDoctor(io, home, configuredRoot) {
+    const rows = [];
+    const loaded = await loadMergeState(io, home);
+    const counts = countRows(loaded.state.rows);
+    rows.push({
+        key: 'state',
+        label: '合并状态',
+        status: loaded.note === undefined ? 'ok' : 'warn',
+        detail: loaded.note ?? 'pairs ' + String(loaded.state.rows.length) + '；verify ' + String(counts.verify) + ' / pending ' + String(counts.pending) + ' / fuse ' + String(counts.fuse) + ' / skipped ' + String(counts.skipped),
+    });
+    const modelRoot = configuredRoot !== undefined && configuredRoot !== '' ? configuredRoot : process.env.SKILL_MERGE_MODELS_ROOT;
+    if (modelRoot === undefined || modelRoot === '') {
+        rows.push({ key: 'models', label: '合并模型', status: 'warn', detail: '未设置 SKILL_MERGE_MODELS_ROOT；合并扫描会 fail loud' });
+    }
+    else {
+        const int8 = join(modelRoot, 'potion-multilingual-128M-int8');
+        const pca = join(modelRoot, 'potion-multilingual-128M-pca64-int8');
+        const ok = await io.exists(int8) && await io.exists(pca);
+        rows.push({ key: 'models', label: '合并模型', status: ok ? 'ok' : 'warn', detail: ok ? modelRoot : '缺少 int8/pca64：' + modelRoot });
+    }
+    const runsDir = join(home, 'merge', 'runs');
+    const listed = await probeList(io, runsDir);
+    rows.push({
+        key: 'staging',
+        label: '暂存树',
+        status: listed.kind === 'unknown' ? 'unknown' : 'ok',
+        detail: listed.kind === 'unknown'
+            ? '无法列出 ' + runsDir + '：' + listed.reason
+            : listed.kind === 'absent' ? '0 个 run 目录' : String(listed.value.length) + ' 个 run 目录',
+    });
+    rows.push({
+        key: 'staging-path',
+        label: '暂存路径',
+        status: 'ok',
+        detail: stagingRoot(home, '<runId>'),
+    });
+    return rows;
+}
+//# sourceMappingURL=doctor.js.map

package/lib/types/domain/claim.d.ts

@@ -0,0 +1,10 @@
+/** Pure approve-claim lease. No IO. */
+export interface Claim {
+    readonly id: string;
+    readonly token: string;
+    readonly expiresAt: number;
+}
+export declare function acquireClaim(current: Claim | undefined, now: number, leaseMs: number, token: string): Claim | undefined;
+export declare function releaseClaim(current: Claim | undefined, token: string): Claim | undefined;
+export declare function isClaimExpired(current: Claim | undefined, now: number): boolean;
+//# sourceMappingURL=claim.d.ts.map

package/lib/types/domain/claim.js

@@ -0,0 +1,12 @@
+export function acquireClaim(current, now, leaseMs, token) {
+    if (current !== undefined && current.expiresAt > now)
+        return undefined;
+    return { id: 'claim', token, expiresAt: now + Math.max(1, leaseMs) };
+}
+export function releaseClaim(current, token) {
+    return current?.token === token ? undefined : current;
+}
+export function isClaimExpired(current, now) {
+    return current !== undefined && current.expiresAt <= now;
+}
+//# sourceMappingURL=claim.js.map

package/lib/types/domain/commit-journal-store.d.ts

@@ -0,0 +1,6 @@
+import type { EvolutionIoLike } from '@lmzhen/dsh-evolution-core';
+import type { CommitJournal } from './commit-journal.ts';
+export declare function journalPath(home: string, runId: string): string;
+export declare function writeJournal(io: EvolutionIoLike, home: string, journal: CommitJournal): Promise<string>;
+export declare function readJournal(io: EvolutionIoLike, home: string, runId: string): Promise<CommitJournal | null>;
+//# sourceMappingURL=commit-journal-store.d.ts.map

package/lib/types/domain/commit-journal-store.js

@@ -0,0 +1,22 @@
+/** Durable commit journal: <home>/merge/journals/<run>.json. */
+import { join } from 'node:path';
+export function journalPath(home, runId) {
+    return join(home, 'merge', 'journals', runId.replace(/[^A-Za-z0-9_-]+/g, '_') + '.json');
+}
+export async function writeJournal(io, home, journal) {
+    const path = journalPath(home, journal.runId);
+    await io.writeText(path, JSON.stringify(journal, null, 2));
+    return path;
+}
+export async function readJournal(io, home, runId) {
+    const raw = await io.readText(journalPath(home, runId));
+    if (raw === null)
+        return null;
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
+//# sourceMappingURL=commit-journal-store.js.map

package/lib/types/domain/commit-journal.d.ts

@@ -0,0 +1,16 @@
+/** Pure commit-journal phases for target-first merge. */
+export type JournalPhase = 'prepared' | 'target-written' | 'sources-archived' | 'committed' | 'rolled-back' | 'failed';
+export interface CommitJournal {
+    readonly runId: string;
+    readonly unitId?: string;
+    readonly target: string;
+    readonly create: boolean;
+    readonly sources: readonly string[];
+    readonly phase: JournalPhase;
+    readonly updatedAt: string;
+}
+export declare function advanceJournal(journal: CommitJournal, phase: JournalPhase, at: string): CommitJournal;
+export type JournalRecovery = 'none' | 'retry-commit' | 'rollback-target' | 'rollback-sources';
+/** What a restart may do with the last durable phase. */
+export declare function recoveryFor(journal: CommitJournal): JournalRecovery;
+//# sourceMappingURL=commit-journal.d.ts.map

package/lib/types/domain/commit-journal.js

@@ -0,0 +1,25 @@
+const NEXT = {
+    prepared: ['target-written', 'failed'],
+    'target-written': ['sources-archived', 'rolled-back', 'failed'],
+    'sources-archived': ['committed', 'rolled-back', 'failed'],
+    committed: [],
+    'rolled-back': [],
+    failed: [],
+};
+export function advanceJournal(journal, phase, at) {
+    if (!NEXT[journal.phase].includes(phase))
+        throw new Error('invalid journal transition: ' + journal.phase + ' -> ' + phase);
+    return { ...journal, phase, updatedAt: at };
+}
+/** What a restart may do with the last durable phase. */
+export function recoveryFor(journal) {
+    switch (journal.phase) {
+        case 'prepared': return 'retry-commit';
+        case 'target-written': return 'rollback-target';
+        case 'sources-archived': return 'rollback-sources';
+        case 'committed':
+        case 'rolled-back':
+        case 'failed': return 'none';
+    }
+}
+//# sourceMappingURL=commit-journal.js.map

package/lib/types/domain/errors.d.ts

@@ -0,0 +1,10 @@
+/** Pure merge error rendering: parameter errors are two lines, runtime/target failures three. */
+export type MergeErrorKind = 'parameter' | 'runtime' | 'target' | 'approval';
+export interface MergeError {
+    readonly kind: MergeErrorKind;
+    readonly code: string;
+    readonly message: string;
+    readonly detail?: string;
+}
+export declare function formatMergeError(error: MergeError): string;
+//# sourceMappingURL=errors.d.ts.map

package/lib/types/domain/errors.js

@@ -0,0 +1,7 @@
+export function formatMergeError(error) {
+    if (error.kind === 'parameter')
+        return 'merge: ' + error.message + ' (' + error.code + ')';
+    const detail = '\n' + (error.detail ?? 'no additional detail');
+    return 'merge failed: ' + error.message + ' (' + error.code + ')' + detail + '\nnext: fix the target or rerun after the cause is gone';
+}
+//# sourceMappingURL=errors.js.map

package/lib/types/domain/failure-route.d.ts

@@ -0,0 +1,25 @@
+/** Pure failure routing for merge errors. */
+export type MergeFailureRoute = {
+    readonly kind: 'parameter';
+    readonly reportOnly: false;
+} | {
+    readonly kind: 'source-gone';
+    readonly reportOnly: true;
+} | {
+    readonly kind: 'target-taken';
+    readonly reportOnly: true;
+} | {
+    readonly kind: 'validation';
+    readonly reportOnly: true;
+} | {
+    readonly kind: 'commit';
+    readonly reportOnly: true;
+} | {
+    readonly kind: 'schema';
+    readonly reportOnly: true;
+} | {
+    readonly kind: 'runtime';
+    readonly reportOnly: true;
+};
+export declare function routeFailure(code: string): MergeFailureRoute;
+//# sourceMappingURL=failure-route.d.ts.map

package/lib/types/domain/failure-route.js

@@ -0,0 +1,22 @@
+const PARAMETER = new Set(['bad-pair', 'bad-target', 'bad-flag', 'usage']);
+const SOURCE_GONE = new Set(['source-gone', 'source-missing']);
+const TARGET_TAKEN = new Set(['target-taken', 'target-exists']);
+const VALIDATION = new Set(['validation-failed', 'invalid-decision']);
+const COMMIT = new Set(['commit-failed', 'commit-refused']);
+const SCHEMA = new Set(['schema-invalid', 'schema-version']);
+export function routeFailure(code) {
+    if (PARAMETER.has(code))
+        return { kind: 'parameter', reportOnly: false };
+    if (SOURCE_GONE.has(code))
+        return { kind: 'source-gone', reportOnly: true };
+    if (TARGET_TAKEN.has(code))
+        return { kind: 'target-taken', reportOnly: true };
+    if (VALIDATION.has(code))
+        return { kind: 'validation', reportOnly: true };
+    if (COMMIT.has(code))
+        return { kind: 'commit', reportOnly: true };
+    if (SCHEMA.has(code))
+        return { kind: 'schema', reportOnly: true };
+    return { kind: 'runtime', reportOnly: true };
+}
+//# sourceMappingURL=failure-route.js.map

package/lib/types/domain/indexes.d.ts

@@ -0,0 +1,21 @@
+/** Pure pairKey result index and archived-history projection. No IO. */
+export interface PairIndexEntryV2 {
+    readonly pairKey: string;
+    readonly runId: string;
+    readonly result: 'merged' | 'kept' | 'failed' | 'cancelled' | 'undone';
+    readonly target?: string;
+    readonly reportRef?: string;
+}
+export type HistoryKind = 'merged' | 'deleted' | 'split' | 'other';
+export interface HistoryRecord {
+    readonly name: string;
+    readonly kind: HistoryKind;
+    readonly reason: string;
+    readonly lastVersion: number;
+    readonly archivedAt: string;
+    readonly sourceRunId?: string;
+}
+export declare function putPair(index: ReadonlyMap<string, PairIndexEntryV2>, entry: PairIndexEntryV2): Map<string, PairIndexEntryV2>;
+export declare function historyRecord(input: HistoryRecord): HistoryRecord;
+export declare function summarizeHistory(records: readonly HistoryRecord[]): Record<HistoryKind, number>;
+//# sourceMappingURL=indexes.d.ts.map

package/lib/types/domain/indexes.js

@@ -0,0 +1,15 @@
+export function putPair(index, entry) {
+    const next = new Map(index);
+    next.set(entry.pairKey, entry);
+    return next;
+}
+export function historyRecord(input) {
+    return { ...input, lastVersion: Math.max(1, Math.trunc(input.lastVersion)) };
+}
+export function summarizeHistory(records) {
+    const counts = { merged: 0, deleted: 0, split: 0, other: 0 };
+    for (const record of records)
+        counts[record.kind] += 1;
+    return counts;
+}
+//# sourceMappingURL=indexes.js.map

package/lib/types/domain/ledger.d.ts

@@ -0,0 +1,17 @@
+import type { MergeRowV2 } from './row.ts';
+import { type MergeQueue } from './state.ts';
+export interface LedgerV2 {
+    readonly schemaVersion: 2;
+    readonly rows: readonly MergeRowV2[];
+}
+export interface LedgerParseResult {
+    readonly ok: boolean;
+    readonly ledger: LedgerV2;
+    readonly note?: string;
+}
+export declare function parseLedger(raw: string | null): LedgerParseResult;
+export declare function upsert(rows: readonly MergeRowV2[], row: MergeRowV2): readonly MergeRowV2[];
+export declare function remove(rows: readonly MergeRowV2[], pairKey: string): readonly MergeRowV2[];
+export declare function rowsOfQueue(rows: readonly MergeRowV2[], queue: MergeQueue): readonly MergeRowV2[];
+export declare function activeCounts(rows: readonly MergeRowV2[]): Record<MergeQueue, number>;
+//# sourceMappingURL=ledger.d.ts.map

package/lib/types/domain/ledger.js

@@ -0,0 +1,65 @@
+/** Pure v2 ledger normalization/projection. No IO. */
+import { migrateV1Row } from "./migrate-v1.js";
+import { queueOf } from "./state.js";
+function isRow(value) {
+    const row = value;
+    return typeof row.id === 'string' && typeof row.pairKey === 'string' && typeof row.a === 'string' && typeof row.b === 'string'
+        && typeof row.state === 'string' && typeof row.createdAt === 'string' && typeof row.updatedAt === 'string';
+}
+export function parseLedger(raw) {
+    if (raw === null)
+        return { ok: true, ledger: { schemaVersion: 2, rows: [] } };
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        return { ok: false, ledger: { schemaVersion: 2, rows: [] }, note: 'invalid json' };
+    }
+    const body = parsed;
+    if (!Array.isArray(body.rows))
+        return { ok: false, ledger: { schemaVersion: 2, rows: [] }, note: 'rows missing' };
+    const rows = [];
+    let skipped = 0;
+    for (const value of body.rows) {
+        if (body.schemaVersion === 1) {
+            const legacy = value;
+            if (typeof legacy.id !== 'string' || typeof legacy.pairKey !== 'string' || typeof legacy.a !== 'string' || typeof legacy.b !== 'string' || typeof legacy.state !== 'string' || typeof legacy.createdAt !== 'string' || typeof legacy.updatedAt !== 'string') {
+                skipped += 1;
+                continue;
+            }
+            const row = migrateV1Row(legacy);
+            rows.push(row);
+            continue;
+        }
+        if (!isRow(value)) {
+            skipped += 1;
+            continue;
+        }
+        rows.push(value);
+    }
+    const note = skipped === 0 ? undefined : String(skipped) + ' invalid row(s) skipped';
+    return { ok: true, ledger: { schemaVersion: 2, rows }, ...(note === undefined ? {} : { note }) };
+}
+export function upsert(rows, row) {
+    const index = rows.findIndex(current => current.pairKey === row.pairKey);
+    if (index < 0)
+        return [...rows, row];
+    return rows.map((current, at) => at === index ? row : current);
+}
+export function remove(rows, pairKey) {
+    return rows.filter(row => row.pairKey !== pairKey);
+}
+export function rowsOfQueue(rows, queue) {
+    return rows.filter(row => queueOf(row.state) === queue);
+}
+export function activeCounts(rows) {
+    const counts = { verify: 0, pending: 0, fuse: 0, skipped: 0 };
+    for (const row of rows) {
+        if (row.expired !== undefined)
+            continue;
+        counts[queueOf(row.state)] += 1;
+    }
+    return counts;
+}
+//# sourceMappingURL=ledger.js.map

package/lib/types/domain/markdown.d.ts

@@ -0,0 +1,2 @@
+export declare function renderMarkdown(source: string): string;
+//# sourceMappingURL=markdown.d.ts.map

package/lib/types/domain/markdown.js

@@ -0,0 +1,57 @@
+/** Minimal safe Markdown renderer for the read-only body route. */
+function escapeHtml(text) {
+    return text.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;');
+}
+export function renderMarkdown(source) {
+    const fence = String.fromCharCode(96, 96, 96);
+    const lines = source.split(/\r?\n/);
+    const out = [];
+    let inCode = false;
+    let inList = false;
+    for (const line of lines) {
+        if (line.startsWith(fence)) {
+            if (inCode) {
+                out.push('</code></pre>');
+                inCode = false;
+            }
+            else {
+                out.push('<pre><code>');
+                inCode = true;
+            }
+            continue;
+        }
+        if (inCode) {
+            out.push(escapeHtml(line));
+            continue;
+        }
+        const heading = /^(#{1,6})\s+(.*)$/.exec(line);
+        if (heading !== null) {
+            if (inList) {
+                out.push('</ul>');
+                inList = false;
+            }
+            const level = heading[1]?.length ?? 1;
+            out.push('<h' + String(level) + '>' + escapeHtml(heading[2] ?? '') + '</h' + String(level) + '>');
+            continue;
+        }
+        if (/^[-*]\s+/.test(line)) {
+            if (!inList) {
+                out.push('<ul>');
+                inList = true;
+            }
+            out.push('<li>' + escapeHtml(line.replace(/^[-*]\s+/, '')) + '</li>');
+            continue;
+        }
+        if (inList) {
+            out.push('</ul>');
+            inList = false;
+        }
+        out.push(line.trim() === '' ? '' : '<p>' + escapeHtml(line) + '</p>');
+    }
+    if (inList)
+        out.push('</ul>');
+    if (inCode)
+        out.push('</code></pre>');
+    return out.join('\n');
+}
+//# sourceMappingURL=markdown.js.map

package/lib/types/domain/migrate-v1.d.ts

@@ -0,0 +1,41 @@
+/** Pure v1→v2 row migration. No IO. */
+import type { MergeState } from './state.ts';
+export interface LegacyMergeRow {
+    readonly id: string;
+    readonly pairKey: string;
+    readonly a: string;
+    readonly b: string;
+    readonly state: 'verify' | 'pending' | 'fuse' | 'skipped';
+    readonly queue?: 'pending' | 'retry' | 'skipped';
+    readonly failure?: unknown;
+    readonly decision?: unknown;
+    readonly runId?: string;
+    readonly unitId?: string;
+    readonly origin?: 'agent' | 'human';
+    readonly attempts?: number;
+    readonly stagingRef?: string;
+    readonly stagingExpiresAt?: number;
+    readonly createdAt: string;
+    readonly updatedAt: string;
+}
+export interface V2Row {
+    readonly schemaVersion: 2;
+    readonly id: string;
+    readonly pairKey: string;
+    readonly a: string;
+    readonly b: string;
+    readonly state: MergeState;
+    readonly queue: 'verify' | 'pending' | 'fuse' | 'skipped';
+    readonly failure?: unknown;
+    readonly decision?: unknown;
+    readonly runId?: string;
+    readonly unitId?: string;
+    readonly origin?: 'agent' | 'human';
+    readonly attempts?: number;
+    readonly stagingRef?: string;
+    readonly stagingExpiresAt?: number;
+    readonly createdAt: string;
+    readonly updatedAt: string;
+}
+export declare function migrateV1Row(row: LegacyMergeRow): V2Row;
+//# sourceMappingURL=migrate-v1.d.ts.map

package/lib/types/domain/migrate-v1.js

@@ -0,0 +1,23 @@
+export function migrateV1Row(row) {
+    const queue = row.state === 'pending' ? 'pending' : row.state === 'skipped' ? 'skipped' : row.state === 'fuse' ? 'fuse' : 'verify';
+    return {
+        schemaVersion: 2,
+        id: row.id,
+        pairKey: row.pairKey,
+        a: row.a,
+        b: row.b,
+        state: row.state,
+        queue,
+        ...(row.failure === undefined ? {} : { failure: row.failure }),
+        ...(row.decision === undefined ? {} : { decision: row.decision }),
+        ...(row.runId === undefined ? {} : { runId: row.runId }),
+        ...(row.unitId === undefined ? {} : { unitId: row.unitId }),
+        ...(row.origin === undefined ? {} : { origin: row.origin }),
+        ...(row.attempts === undefined ? {} : { attempts: row.attempts }),
+        ...(row.stagingRef === undefined ? {} : { stagingRef: row.stagingRef }),
+        ...(row.stagingExpiresAt === undefined ? {} : { stagingExpiresAt: row.stagingExpiresAt }),
+        createdAt: row.createdAt,
+        updatedAt: row.updatedAt,
+    };
+}
+//# sourceMappingURL=migrate-v1.js.map

package/lib/types/domain/pair-index-store.d.ts

@@ -0,0 +1,6 @@
+import type { EvolutionIoLike } from '@lmzhen/dsh-evolution-core';
+import type { PairIndexEntryV2 } from './indexes.ts';
+export declare function pairIndexPath(home: string): string;
+export declare function loadPairIndex(io: EvolutionIoLike, home: string): Promise<Map<string, PairIndexEntryV2>>;
+export declare function recordPair(io: EvolutionIoLike, home: string, entry: PairIndexEntryV2): Promise<void>;
+//# sourceMappingURL=pair-index-store.d.ts.map

package/lib/types/domain/pair-index-store.js

@@ -0,0 +1,25 @@
+/** Durable pairKey index at <home>/merge/pair-index.json. */
+import { join } from 'node:path';
+import { transactIo } from '@lmzhen/dsh-evolution-core';
+import { parsePairIndex, serializePairIndex } from "./pair-index.js";
+export function pairIndexPath(home) {
+    return join(home, 'merge', 'pair-index.json');
+}
+export async function loadPairIndex(io, home) {
+    let raw = null;
+    try {
+        raw = await io.readText(pairIndexPath(home));
+    }
+    catch {
+        return new Map();
+    }
+    return parsePairIndex(raw);
+}
+export async function recordPair(io, home, entry) {
+    await transactIo(io, pairIndexPath(home), (current) => {
+        const index = parsePairIndex(current);
+        index.set(entry.pairKey, entry);
+        return serializePairIndex(index);
+    });
+}
+//# sourceMappingURL=pair-index-store.js.map

package/lib/types/domain/pair-index.d.ts

@@ -0,0 +1,9 @@
+/** Pure pairKey index serialization. No IO. */
+import type { PairIndexEntryV2 } from './indexes.ts';
+export interface PairIndexFile {
+    readonly schemaVersion: 1;
+    readonly entries: readonly PairIndexEntryV2[];
+}
+export declare function parsePairIndex(raw: string | null): Map<string, PairIndexEntryV2>;
+export declare function serializePairIndex(index: ReadonlyMap<string, PairIndexEntryV2>): string;
+//# sourceMappingURL=pair-index.d.ts.map

package/lib/types/domain/pair-index.js

@@ -0,0 +1,28 @@
+export function parsePairIndex(raw) {
+    const index = new Map();
+    if (raw === null)
+        return index;
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        return index;
+    }
+    const body = parsed;
+    if (!Array.isArray(body.entries))
+        return index;
+    for (const value of body.entries) {
+        const entry = value;
+        if (typeof entry.pairKey !== 'string' || typeof entry.runId !== 'string' || typeof entry.result !== 'string')
+            continue;
+        if (!['merged', 'kept', 'failed', 'cancelled', 'undone'].includes(entry.result))
+            continue;
+        index.set(entry.pairKey, entry);
+    }
+    return index;
+}
+export function serializePairIndex(index) {
+    return JSON.stringify({ schemaVersion: 1, entries: [...index.values()] }, null, 2);
+}
+//# sourceMappingURL=pair-index.js.map

package/lib/types/domain/resolve-pair.d.ts

@@ -0,0 +1,11 @@
+/** Pure pairKey lookup over run records. No IO. */
+import type { PairIndexEntryV2 } from './indexes.ts';
+import type { PairRecord } from './run-record.ts';
+export interface PairRunLike {
+    readonly id: string;
+    readonly pairKey?: string;
+    readonly pairs: readonly PairRecord[];
+    readonly resultRef?: string;
+}
+export declare function findPairRun(runs: readonly PairRunLike[], pairKey: string): PairIndexEntryV2 | undefined;
+//# sourceMappingURL=resolve-pair.d.ts.map

package/lib/types/domain/resolve-pair.js

@@ -0,0 +1,17 @@
+export function findPairRun(runs, pairKey) {
+    for (const run of runs) {
+        if (run.pairKey === pairKey) {
+            return { pairKey, runId: run.id, result: 'merged', ...(run.resultRef === undefined ? {} : { reportRef: run.resultRef }) };
+        }
+        const pair = run.pairs.find(item => item.pairKey === pairKey);
+        if (pair !== undefined) {
+            return {
+                pairKey, runId: run.id, result: pair.result === 'undone' ? 'undone' : pair.result === 'kept' ? 'kept' : pair.result === 'failed' ? 'failed' : pair.result === 'cancelled' ? 'cancelled' : 'merged',
+                ...(pair.target?.actual === undefined ? {} : { target: pair.target.actual }),
+                ...(run.resultRef === undefined ? {} : { reportRef: run.resultRef }),
+            };
+        }
+    }
+    return undefined;
+}
+//# sourceMappingURL=resolve-pair.js.map