@lmzhen/dsh-evolution-merge 0.29.0 → 0.30.1

package/lib/types/commit-receipt.d.ts

@@ -6,6 +6,7 @@ export interface CommitReceipt {
     readonly target: string;
     readonly create: boolean;
     readonly sources: readonly string[];
+    readonly pairKey?: string;
     readonly archived: readonly string[];
     readonly at: number;
 }
@@ -13,5 +14,6 @@ export declare function commitReceiptPath(home: string, runId: string): string;
 export declare function durableReceiptDir(home: string, parentRunId: string): string;
 export declare function durableReceiptPath(home: string, parentRunId: string, stageKey: string): string;
 export declare function writeCommitReceipt(io: EvolutionIoLike, home: string, receipt: CommitReceipt): Promise<string>;
+export declare function readCommitReceipts(io: EvolutionIoLike, home: string): Promise<readonly CommitReceipt[]>;
 export declare function readCommitReceipt(io: EvolutionIoLike, home: string, runId: string, target?: string): Promise<CommitReceipt | null>;
 //# sourceMappingURL=commit-receipt.d.ts.map

package/lib/types/commit-receipt.js

@@ -0,0 +1,85 @@
+/**
+ * Commit receipt: <run>/commit.json, written immediately after a successful commit.
+ * It is the idempotency/recovery marker — merge resume and run start read it before
+ * replaying a commit. Receipt write failure must not turn a landed commit into a failure;
+ * the caller reports the warning instead.
+ */
+import { join } from 'node:path';
+import { stagingRoot } from "./staging.js";
+export function commitReceiptPath(home, runId) {
+    return join(stagingRoot(home, runId), 'commit.json');
+}
+export function durableReceiptDir(home, parentRunId) {
+    return join(home, 'merge', 'receipts', parentRunId);
+}
+export function durableReceiptPath(home, parentRunId, stageKey) {
+    const leaf = stageKey.split('/').pop() ?? stageKey;
+    return join(durableReceiptDir(home, parentRunId), leaf + '.json');
+}
+function parseReceipt(raw) {
+    if (raw === null)
+        return null;
+    try {
+        const parsed = JSON.parse(raw);
+        if (typeof parsed.runId !== 'string' || typeof parsed.unitId !== 'string' || typeof parsed.target !== 'string'
+            || typeof parsed.create !== 'boolean' || !Array.isArray(parsed.sources) || !Array.isArray(parsed.archived) || typeof parsed.at !== 'number') {
+            return null;
+        }
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+}
+export async function writeCommitReceipt(io, home, receipt) {
+    const path = commitReceiptPath(home, receipt.runId);
+    await io.writeText(path, JSON.stringify(receipt, null, 2) + '\n');
+    const parent = receipt.parentRunId ?? receipt.runId.split('/pairs/')[0] ?? receipt.runId;
+    await io.writeText(durableReceiptPath(home, parent, receipt.runId), JSON.stringify({ ...receipt, parentRunId: parent }, null, 2) + '\n');
+    return path;
+}
+export async function readCommitReceipts(io, home) {
+    const root = join(home, 'merge', 'receipts');
+    const out = [];
+    let runs;
+    try {
+        runs = await io.list(root);
+    }
+    catch {
+        return out;
+    }
+    for (const run of runs.sort()) {
+        const dir = join(root, run);
+        let files;
+        try {
+            files = await io.list(dir);
+        }
+        catch {
+            continue;
+        }
+        for (const file of files.sort()) {
+            if (!file.endsWith('.json'))
+                continue;
+            const receipt = parseReceipt(await io.readText(join(dir, file)));
+            if (receipt !== null)
+                out.push(receipt);
+        }
+    }
+    return out;
+}
+export async function readCommitReceipt(io, home, runId, target) {
+    const direct = parseReceipt(await io.readText(commitReceiptPath(home, runId)));
+    if (direct !== null && (target === undefined || direct.target === target))
+        return direct;
+    try {
+        const names = await io.list(durableReceiptDir(home, runId));
+        for (const name of names.sort()) {
+            const receipt = parseReceipt(await io.readText(join(durableReceiptDir(home, runId), name)));
+            if (receipt !== null && (target === undefined || receipt.target === target))
+                return receipt;
+        }
+    }
+    catch { /* absent */ }
+    return null;
+}
+//# sourceMappingURL=commit-receipt.js.map

package/lib/types/contracts.d.ts

@@ -4,9 +4,9 @@
  * The data layer keeps four states; the user face collapses verify/fuse into one retry
  * queue and keeps the stage as a chip. The API queue must never expose the raw state.
  */
-export declare const MERGE_STATE_VERSION = 1;
-export type MergePairState = 'verify' | 'pending' | 'fuse' | 'skipped';
-export type MergeQueue = 'pending' | 'retry' | 'skipped';
+export declare const MERGE_STATE_VERSION = 2;
+export type MergePairState = 'verify' | 'pending' | 'approved' | 'fuse' | 'skipped';
+export type MergeQueue = 'verify' | 'pending' | 'fuse' | 'skipped';
 export type MergeStage = 'verify' | 'decide' | 'author' | 'commit';
 export type MergeCommand = 'scan' | 'pair' | 'approve' | 'resume';
 export declare const MERGE_PAIR_STATES: readonly MergePairState[];
@@ -88,7 +88,7 @@ export interface MergeReportPair {
     readonly timing?: MergeTiming;
 }
 export interface MergeReport {
-    readonly schemaVersion: 1;
+    readonly schemaVersion: 2;
     readonly runId: string;
     readonly kind: 'merge';
     readonly command: MergeRunCommand;
@@ -118,12 +118,21 @@ export interface MergeRow {
     readonly b: string;
     readonly state: MergePairState;
     readonly queue: MergeQueue;
+    readonly expired?: 'target-taken' | 'source-changed';
+    readonly reason?: string;
+    readonly target?: {
+        readonly requested: string;
+        readonly actual?: string;
+        readonly created?: boolean;
+    };
     readonly failure?: MergeFailure;
     /** Round-1 decision, persisted for the later approve round. */
     readonly decision?: MergeDecision;
+    readonly sourceRevision?: string;
+    readonly targetRevision?: string;
     readonly runId?: string;
     readonly unitId?: string;
-    readonly origin?: 'agent' | 'human';
+    readonly origin?: 'agent' | 'human' | 'system';
     readonly attempts?: number;
     readonly stagingRef?: string;
     readonly stagingExpiresAt?: number;

package/lib/types/contracts.js

@@ -0,0 +1,57 @@
+/**
+ * Frozen merge-domain vocabulary. No io, no host, no imports from the plugin shell.
+ *
+ * The data layer keeps four states; the user face collapses verify/fuse into one retry
+ * queue and keeps the stage as a chip. The API queue must never expose the raw state.
+ */
+export const MERGE_STATE_VERSION = 2;
+export const MERGE_PAIR_STATES = ['verify', 'pending', 'approved', 'fuse', 'skipped'];
+export const MERGE_QUEUES = ['verify', 'pending', 'fuse', 'skipped'];
+/** User-facing queue of one data state. verify/fuse share retry, not two tabs. */
+export function queueOf(state) {
+    switch (state) {
+        case 'verify': return 'verify';
+        case 'pending': return 'pending';
+        case 'approved':
+        case 'fuse': return 'fuse';
+        case 'skipped': return 'skipped';
+    }
+}
+/** Coarse stage chip; skipped has no active stage. */
+export function stageOf(state) {
+    switch (state) {
+        case 'verify': return 'verify';
+        case 'pending': return 'decide';
+        case 'approved':
+        case 'fuse': return 'author';
+        case 'skipped': return null;
+    }
+}
+/** Stable pair identity; NUL cannot appear in a skill name. */
+export function pairKey(a, b) {
+    return a < b ? a + '\u0000' + b : b + '\u0000' + a;
+}
+/** Deterministic, URL-safe id derived from the pair key (FNV-1a 32). */
+export function rowIdOf(key) {
+    let hash = 0x811c9dc5;
+    for (let index = 0; index < key.length; index += 1) {
+        hash ^= key.charCodeAt(index);
+        hash = Math.imul(hash, 0x01000193) >>> 0;
+    }
+    return 'mr_' + hash.toString(36).padStart(7, '0');
+}
+export function emptyMergeState() {
+    return { schemaVersion: MERGE_STATE_VERSION, rows: [] };
+}
+/** One record can be retried only when the failure says so and names a stage. */
+export const MERGE_MAX_ATTEMPTS = 3;
+export function canRetry(record) {
+    if (record.state === 'skipped')
+        return false;
+    if ((record.attempts ?? 0) >= MERGE_MAX_ATTEMPTS)
+        return false;
+    if (record.failure === undefined)
+        return record.state !== 'pending';
+    return record.failure.retryable && record.failure.retryFrom !== 'none';
+}
+//# sourceMappingURL=contracts.js.map

package/lib/types/coordinator.d.ts

@@ -36,6 +36,9 @@ export type MergeEvent = {
     readonly type: 'round2-fail';
     readonly failure: MergeFailure;
     readonly at: string;
+} | {
+    readonly type: 'round2-cancel';
+    readonly at: string;
 } | {
     readonly type: 'round2-success';
     readonly unitId?: string;

package/lib/types/coordinator.js

@@ -0,0 +1,131 @@
+/**
+ * Pure merge transition table. No io, no run shell, no subagents.
+ *
+ * Every transition returns the whole next row (or a drop), so the caller can persist it
+ * through mutateMergeState in one transaction. Invalid transitions are refused by name;
+ * a caller never "repairs" a row by guessing which state the operator meant.
+ */
+import { pairKey, queueOf, rowIdOf, } from "./contracts.js";
+function invalid(event, state) {
+    return {
+        ok: false,
+        code: 'invalid-transition',
+        message: 'cannot apply ' + event.type + ' to ' + (state ?? 'no row'),
+    };
+}
+/** Drop fields that must not survive a transition; optional fields stay absent. */
+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.reason === undefined ? {} : { reason: row.reason }),
+        ...(row.target === undefined ? {} : { target: row.target }),
+    };
+}
+function next(row, at, state, patch = {}) {
+    return {
+        ok: true,
+        row: {
+            ...base(row, at),
+            state,
+            queue: queueOf(state),
+            ...patch,
+        },
+    };
+}
+export function transition(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);
+    switch (event.type) {
+        case 'round1-keep':
+            return current.state === 'verify' ? next(current, event.at, 'skipped', { origin: 'agent' }) : invalid(event, current.state);
+        case 'round1-merge':
+            if (current.state !== 'verify')
+                return invalid(event, current.state);
+            return event.approval === 'on'
+                ? next(current, event.at, 'pending', { ...(event.decision === undefined ? {} : { decision: event.decision }), ...(event.stagingRef === undefined ? {} : { stagingRef: event.stagingRef }), ...(event.stagingExpiresAt === undefined ? {} : { stagingExpiresAt: event.stagingExpiresAt }) })
+                : next(current, event.at, 'approved', { ...(event.decision === undefined ? {} : { decision: event.decision }), ...(event.stagingRef === undefined ? {} : { stagingRef: event.stagingRef }), ...(event.stagingExpiresAt === undefined ? {} : { stagingExpiresAt: event.stagingExpiresAt }) });
+        case 'round1-fail':
+            return current.state === 'verify'
+                ? next(current, event.at, 'verify', { failure: event.failure, attempts: (current.attempts ?? 0) + 1 })
+                : invalid(event, current.state);
+        case 'approve':
+            return current.state === 'pending'
+                ? next(current, event.at, 'approved', { ...(event.runId === undefined ? {} : { runId: event.runId }) })
+                : invalid(event, current.state);
+        case 'reject':
+            return current.state === 'pending' ? next(current, event.at, 'skipped', { origin: 'human' }) : invalid(event, current.state);
+        case 'round2-cancel':
+            return current.state === 'fuse' || current.state === 'approved'
+                ? next(current, event.at, 'approved')
+                : invalid(event, current.state);
+        case 'round2-fail':
+            return current.state === 'fuse' || current.state === 'approved'
+                ? next(current, event.at, 'approved', { failure: event.failure, attempts: (current.attempts ?? 0) + 1 })
+                : invalid(event, current.state);
+        case 'round2-success':
+            return current.state === 'fuse' || current.state === 'approved'
+                ? { ok: true, row: null }
+                : invalid(event, current.state);
+        case 'restore':
+            return current.state === 'skipped'
+                ? next(current, event.at, 'verify')
+                : invalid(event, current.state);
+    }
+}
+//# sourceMappingURL=coordinator.js.map

package/lib/types/decision.js

@@ -0,0 +1,61 @@
+function extractJson(text) {
+    const fenced = /\`\`\`(?:json)?\s*([\s\S]*?)\`\`\`/i.exec(text);
+    const body = fenced?.[1] ?? text;
+    const start = body.indexOf('{');
+    if (start < 0)
+        return undefined;
+    let depth = 0;
+    for (let index = start; index < body.length; index += 1) {
+        if (body[index] === '{')
+            depth += 1;
+        else if (body[index] === '}') {
+            depth -= 1;
+            if (depth === 0) {
+                try {
+                    return JSON.parse(body.slice(start, index + 1));
+                }
+                catch {
+                    return undefined;
+                }
+            }
+        }
+    }
+    return undefined;
+}
+export function parseDecision(text, pair) {
+    if (text === undefined || text.trim() === '')
+        return { ok: false, code: 'decision-invalid', message: 'empty decision text' };
+    const value = extractJson(text);
+    if (typeof value !== 'object' || value === null)
+        return { ok: false, code: 'decision-invalid', message: 'decision is not a JSON object' };
+    const record = value;
+    const shouldMerge = record.shouldMerge === true || record.should_merge === true;
+    const mode = record.mode;
+    if (mode !== 'merge-into-existing' && mode !== 'create-umbrella' && mode !== 'keep') {
+        return { ok: false, code: 'decision-invalid', message: 'mode must be merge-into-existing, create-umbrella or keep' };
+    }
+    const target = typeof record.target === 'string' ? record.target.trim() : '';
+    const sources = Array.isArray(record.sources) ? record.sources.filter((item) => typeof item === 'string').map(item => item.trim()).filter(Boolean) : [];
+    const rationale = typeof record.rationale === 'string' ? record.rationale.trim() : '';
+    if (!shouldMerge || mode === 'keep') {
+        return { ok: true, decision: { shouldMerge: false, mode: 'keep', target, sources, rationale } };
+    }
+    if (target === '')
+        return { ok: false, code: 'decision-invalid', message: 'merge decision needs target' };
+    if (sources.length === 0)
+        return { ok: false, code: 'decision-invalid', message: 'merge decision needs sources' };
+    if (!sources.includes(pair.a) || !sources.includes(pair.b))
+        return { ok: false, code: 'decision-invalid', message: 'sources must include both pair skills' };
+    return {
+        ok: true,
+        decision: {
+            shouldMerge: true,
+            mode,
+            target,
+            sources,
+            rationale,
+            ...(typeof record.confidence === 'number' ? { confidence: record.confidence } : {}),
+        },
+    };
+}
+//# sourceMappingURL=decision.js.map

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