@lmzhen/dsh-evolution-merge 0.29.0 → 0.30.0

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

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

@@ -0,0 +1,113 @@
+import { type MergeState } from './state.ts';
+import type { MergeDecision, MergeFailure } from '../contracts.ts';
+export interface MergeRowV2 {
+    readonly id: string;
+    readonly pairKey: string;
+    readonly a: string;
+    readonly b: string;
+    readonly state: MergeState;
+    readonly queue: 'verify' | 'pending' | 'fuse' | 'skipped';
+    readonly failure?: MergeFailure;
+    readonly decision?: MergeDecision;
+    readonly sourceRevision?: string;
+    readonly targetRevision?: string;
+    readonly runId?: string;
+    readonly unitId?: string;
+    readonly origin?: 'agent' | 'human' | 'system';
+    readonly attempts?: number;
+    readonly stagingRef?: string;
+    readonly stagingExpiresAt?: number;
+    readonly target?: {
+        readonly requested: string;
+        readonly actual?: string;
+        readonly created?: boolean;
+    };
+    readonly reason?: string;
+    readonly expired?: 'target-taken' | 'source-changed';
+    readonly createdAt: string;
+    readonly updatedAt: string;
+}
+export type MergeRowEvent = {
+    readonly type: 'candidate';
+    readonly a: string;
+    readonly b: string;
+    readonly at: string;
+} | {
+    readonly type: 'round1-start';
+    readonly at: string;
+} | {
+    readonly type: 'round1-keep';
+    readonly at: string;
+} | {
+    readonly type: 'round1-merge';
+    readonly approval: 'on' | 'off';
+    readonly decision?: MergeDecision;
+    readonly stagingRef?: string;
+    readonly stagingExpiresAt?: number;
+    readonly at: string;
+} | {
+    readonly type: 'round1-fail';
+    readonly failure: MergeFailure;
+    readonly at: string;
+} | {
+    readonly type: 'approve';
+    readonly runId?: string;
+    readonly at: string;
+} | {
+    readonly type: 'reject';
+    readonly at: string;
+} | {
+    readonly type: 'round2-start';
+    readonly at: string;
+} | {
+    readonly type: 'round2-fail';
+    readonly failure: MergeFailure;
+    readonly at: string;
+} | {
+    readonly type: 'round2-success';
+    readonly unitId?: string;
+    readonly at: string;
+} | {
+    readonly type: 'restore';
+    readonly at: string;
+} | {
+    readonly type: 'discard';
+    readonly at: string;
+} | {
+    readonly type: 'source-gone';
+    readonly at: string;
+} | {
+    readonly type: 'target-taken';
+    readonly at: string;
+} | {
+    readonly type: 'source-changed';
+    readonly at: string;
+} | {
+    readonly type: 'staging-expired';
+    readonly at: string;
+} | {
+    readonly type: 'round2-cancel';
+    readonly at: string;
+} | {
+    readonly type: 'timeout';
+    readonly at: string;
+} | {
+    readonly type: 'cancel';
+    readonly at: string;
+} | {
+    readonly type: 'gate-keep';
+    readonly a: string;
+    readonly b: string;
+    readonly reason?: string;
+    readonly at: string;
+};
+export type RowTransitionResult = {
+    readonly ok: true;
+    readonly row: MergeRowV2 | null;
+} | {
+    readonly ok: false;
+    readonly code: 'invalid-transition';
+    readonly message: string;
+};
+export declare function transitionRow(current: MergeRowV2 | undefined, event: MergeRowEvent): RowTransitionResult;
+//# sourceMappingURL=row.d.ts.map

package/lib/types/domain/row.js

@@ -0,0 +1,111 @@
+/** Pure v2 row transitions for G1 cutover. No IO. */
+import { pairKey, rowIdOf } from "../contracts.js";
+import { queueOf, transition as stateTransition } from "./state.js";
+function base(row, at) {
+    return {
+        id: row.id, pairKey: row.pairKey, a: row.a, b: row.b,
+        state: row.state, queue: row.queue, createdAt: row.createdAt, updatedAt: at,
+        ...(row.runId === undefined ? {} : { runId: row.runId }),
+        ...(row.unitId === undefined ? {} : { unitId: row.unitId }),
+        ...(row.origin === undefined ? {} : { origin: row.origin }),
+        ...(row.decision === undefined ? {} : { decision: row.decision }),
+        ...(row.sourceRevision === undefined ? {} : { sourceRevision: row.sourceRevision }),
+        ...(row.targetRevision === undefined ? {} : { targetRevision: row.targetRevision }),
+        ...(row.attempts === undefined ? {} : { attempts: row.attempts }),
+        ...(row.stagingRef === undefined ? {} : { stagingRef: row.stagingRef }),
+        ...(row.stagingExpiresAt === undefined ? {} : { stagingExpiresAt: row.stagingExpiresAt }),
+        ...(row.expired === undefined ? {} : { expired: row.expired }),
+        ...(row.target === undefined ? {} : { target: row.target }),
+        ...(row.reason === undefined ? {} : { reason: row.reason }),
+    };
+}
+function next(row, at, state, patch = {}) {
+    return { ok: true, row: { ...base(row, at), state, queue: queueOf(state), ...patch } };
+}
+function invalid(event, state) {
+    return { ok: false, code: 'invalid-transition', message: 'cannot apply ' + event.type + ' to ' + (state ?? 'no row') };
+}
+export function transitionRow(current, event) {
+    if (event.type === 'candidate') {
+        if (current !== undefined)
+            return { ok: true, row: current };
+        const key = pairKey(event.a, event.b);
+        return { ok: true, row: { id: rowIdOf(key), pairKey: key, a: event.a, b: event.b, state: 'verify', queue: 'verify', createdAt: event.at, updatedAt: event.at } };
+    }
+    if (event.type === 'source-gone')
+        return { ok: true, row: null };
+    if (event.type === 'gate-keep') {
+        if (current !== undefined)
+            return { ok: true, row: current };
+        const key = pairKey(event.a, event.b);
+        return { ok: true, row: { id: rowIdOf(key), pairKey: key, a: event.a, b: event.b, state: 'skipped', queue: 'skipped', origin: 'agent', createdAt: event.at, updatedAt: event.at } };
+    }
+    if (current === undefined)
+        return invalid(event, undefined);
+    if (event.type === 'discard') {
+        return current.state === 'pending' || current.state === 'approved' || current.state === 'fuse'
+            ? { ok: true, row: null }
+            : invalid(event, current.state);
+    }
+    if (event.type === 'restore') {
+        return current.state === 'skipped' ? next(current, event.at, 'verify') : invalid(event, current.state);
+    }
+    if (event.type === 'target-taken' || event.type === 'source-changed') {
+        return current.state === 'pending' || current.state === 'approved' || current.state === 'fuse'
+            ? next(current, event.at, current.state, { expired: event.type })
+            : invalid(event, current.state);
+    }
+    if (event.type === 'staging-expired') {
+        return current.state === 'fuse' || current.state === 'approved'
+            ? next(current, event.at, 'approved')
+            : invalid(event, current.state);
+    }
+    if (event.type === 'round2-cancel' || event.type === 'timeout' || event.type === 'cancel') {
+        return current.state === 'fuse' ? next(current, event.at, 'approved') : { ok: true, row: current };
+    }
+    const mapped = event.type === 'round2-success'
+        ? { type: 'round2-merged' }
+        : event.type === 'round2-fail'
+            ? { type: 'round2-fail' }
+            : event.type === 'round1-merge'
+                ? { type: 'round1-merge', approval: event.approval === 'on' }
+                : event.type === 'round1-start'
+                    ? { type: 'round1-start' }
+                    : event.type === 'round2-start'
+                        ? { type: 'round2-start' }
+                        : event.type === 'round1-keep'
+                            ? { type: 'round1-keep' }
+                            : event.type === 'round1-fail'
+                                ? { type: 'round1-fail' }
+                                : event.type === 'approve'
+                                    ? { type: 'approve' }
+                                    : { type: 'reject' };
+    const moved = stateTransition(current.state, mapped);
+    if (!moved.ok)
+        return invalid(event, current.state);
+    if (moved.state === null)
+        return { ok: true, row: null };
+    const patch = {};
+    if (event.type === 'round1-merge') {
+        if (event.decision !== undefined)
+            patch.decision = event.decision;
+        if (event.stagingRef !== undefined)
+            patch.stagingRef = event.stagingRef;
+        if (event.stagingExpiresAt !== undefined)
+            patch.stagingExpiresAt = event.stagingExpiresAt;
+    }
+    if (event.type === 'approve' && event.runId !== undefined)
+        patch.runId = event.runId;
+    if (event.type === 'round1-fail' || event.type === 'round2-fail') {
+        patch.failure = event.failure;
+        patch.attempts = (current.attempts ?? 0) + 1;
+    }
+    if (event.type === 'round1-keep')
+        patch.origin = 'agent';
+    if (event.type === 'reject')
+        patch.origin = 'human';
+    if (event.type === 'round2-success' && event.unitId !== undefined)
+        patch.unitId = event.unitId;
+    return next(current, event.at, moved.state, patch);
+}
+//# sourceMappingURL=row.js.map

package/lib/types/domain/run-record.d.ts

@@ -0,0 +1,45 @@
+/** Pure RunRecord v2 types and derived 9-state projection. No IO. */
+export type RunStatus = 'running' | 'succeeded' | 'failed' | 'cancelled' | 'interrupted' | 'orphan';
+export type MergeStatus = 'running' | 'succeeded' | 'failed' | 'cancelled' | 'awaiting-approval' | 'undone' | 'superseded' | 'interrupted' | 'orphan';
+export type PairResult = 'pending' | 'merged' | 'kept' | 'failed' | 'cancelled' | 'undone';
+export interface PairRecord {
+    readonly pairKey: string;
+    readonly a: string;
+    readonly b: string;
+    readonly result: PairResult;
+    readonly target?: {
+        readonly requested: string;
+        readonly actual?: string;
+        readonly created?: boolean;
+    };
+    readonly stagingRef?: string;
+    readonly committed?: boolean;
+}
+export interface PairIndexEntry {
+    readonly pairKey: string;
+    readonly runId: string;
+    readonly result: PairResult;
+    readonly target?: string;
+    readonly reportRef?: string;
+}
+export interface RunRecordV2 {
+    readonly id: string;
+    readonly kind: 'merge';
+    readonly status: RunStatus;
+    readonly stage?: 'screening' | 'decide' | 'author' | 'commit' | 'settle';
+    readonly approval?: 'on' | 'off';
+    readonly parentRunId?: string;
+    readonly pairKey?: string;
+    readonly plane?: 'local' | 'foreign';
+    readonly startedAt: number;
+    readonly updatedAt: number;
+    readonly endedAt?: number;
+    readonly resultRef?: string;
+    readonly failure?: string;
+    readonly stagingRef?: string;
+    readonly pairs: readonly PairRecord[];
+    readonly supersededAt?: number;
+}
+export declare function deriveMergeStatus(record: RunRecordV2): MergeStatus;
+export declare function allCommittedUndone(record: RunRecordV2): boolean;
+//# sourceMappingURL=run-record.d.ts.map

package/lib/types/domain/run-record.js

@@ -0,0 +1,24 @@
+export function deriveMergeStatus(record) {
+    if (record.supersededAt !== undefined)
+        return 'superseded';
+    if (record.status === 'interrupted')
+        return 'interrupted';
+    if (record.status === 'orphan')
+        return 'orphan';
+    if (record.status === 'failed' || record.status === 'cancelled')
+        return record.status;
+    if (record.status === 'running') {
+        return record.approval === 'on' && record.pairs.some(pair => pair.result === 'pending')
+            ? 'awaiting-approval'
+            : 'running';
+    }
+    const committed = record.pairs.filter(pair => pair.committed === true);
+    if (committed.length > 0 && committed.every(pair => pair.result === 'undone'))
+        return 'undone';
+    return 'succeeded';
+}
+export function allCommittedUndone(record) {
+    const committed = record.pairs.filter(pair => pair.committed === true);
+    return committed.length > 0 && committed.every(pair => pair.result === 'undone');
+}
+//# sourceMappingURL=run-record.js.map