@lmzhen/dsh-evolution-merge 0.46.0 → 0.48.0

package/lib/types/adapters/engine-screen.d.ts

@@ -37,9 +37,6 @@ export interface CandidateSelection {
     readonly reportOnly: readonly unknown[];
     readonly candidatePairs?: number;
 }
-export type ScreeningCandidates = readonly MergeCandidate[] & {
-    readonly candidatePairs?: number;
-};
 export interface EngineScreeningDeps {
     readonly io: EvolutionIoLike;
     readonly home: string;

package/lib/types/authoring-flow.d.ts

@@ -60,5 +60,10 @@ export type AuthoringResult = {
     readonly findings?: readonly RuleFinding[];
     readonly lengths?: Readonly<Record<string, number>>;
 };
+/** The target facts both authoring entries may refuse on before writing anything. */
+export declare function targetAdmission(target: string, targetCard: Pick<SkillCard, 'managed' | 'protectionUnknown' | 'protectedBy'> | undefined, createMode: boolean, isBlocked?: (name: string) => boolean | Promise<boolean>): Promise<{
+    readonly code: string;
+    readonly message: string;
+} | null>;
 export declare function runAuthoring(options: RunAuthoringOptions): Promise<AuthoringResult>;
 //# sourceMappingURL=authoring-flow.d.ts.map

package/lib/types/authoring-flow.js

@@ -6,9 +6,21 @@ import { DEFAULT_SKILL_LIMITS } from '@lmzhen/dsh-evolution-core';
 import { limitsSnapshotOf } from "./domain/merge-limits.js";
 import { buildValidationPlan } from "./domain/validation-plan.js";
 import { manifestFilesOf, missingManifestFile, parseAuthoringManifest } from "./domain/authoring-manifest.js";
+/** The target facts both authoring entries may refuse on before writing anything. */
+export async function targetAdmission(target, targetCard, createMode, isBlocked) {
+    if (target.includes('/') || target.includes(':'))
+        return { code: 'target-invalid', message: 'target must be a bare skill name: ' + target };
+    if (!createMode && targetCard !== undefined) {
+        if (targetCard.managed !== true)
+            return { code: 'target-not-managed', message: 'target is not family-managed: ' + target };
+        if (targetCard.protectionUnknown === true || targetCard.protectedBy != null)
+            return { code: 'target-protected', message: 'target is protected (' + (targetCard.protectedBy ?? 'unknown') + '): ' + target };
+    }
+    if (!createMode && await isBlocked?.(target) === true)
+        return { code: 'target-blocked', message: 'target is blocked by curator: ' + target };
+    return null;
+}
 export async function runAuthoring(options) {
-    if (options.target.includes('/') || options.target.includes(':'))
-        return { ok: false, code: 'target-invalid', message: 'target must be a bare skill name: ' + options.target };
     const targetCard = options.cards.find(card => card.name === options.target);
     // A decision can name a fresh target yet say merge-into-existing (the model's vocabulary is
     // about intent, not existence). The target card is the authoritative existence fact: when it is
@@ -17,14 +29,9 @@ export async function runAuthoring(options) {
     const requestedMode = options.mode ?? (targetCard === undefined ? 'create-umbrella' : 'merge-into-existing');
     const mode = requestedMode === 'merge-into-existing' && targetCard === undefined ? 'create-umbrella' : requestedMode;
     const createMode = mode === 'create-umbrella';
-    if (!createMode && targetCard !== undefined) {
-        if (targetCard.managed !== true)
-            return { ok: false, code: 'target-not-managed', message: 'target is not family-managed: ' + options.target };
-        if (targetCard.protectionUnknown === true || targetCard.protectedBy != null)
-            return { ok: false, code: 'target-protected', message: 'target is protected (' + (targetCard.protectedBy ?? 'unknown') + '): ' + options.target };
-    }
-    if (!createMode && await options.isBlocked?.(options.target) === true)
-        return { ok: false, code: 'target-blocked', message: 'target is blocked by curator: ' + options.target };
+    const targetRefusal = await targetAdmission(options.target, targetCard, createMode, options.isBlocked);
+    if (targetRefusal !== null)
+        return { ok: false, code: targetRefusal.code, message: targetRefusal.message };
     const stageKey = options.stageKey ?? options.runId;
     if (options.reuseStaging === true) {
         if (!await setStagingTarget(options.io, options.home, stageKey, options.target, mode))

package/lib/types/commit-execute.js

@@ -1,7 +1,6 @@
 import { assembleStagedCommit } from "./commit-assembly.js";
 import { writeCommitReceipt } from "./commit-receipt.js";
 import { pairKey } from "./contracts.js";
-import { writeJournal } from "./domain/commit-journal-store.js";
 import { evidenceSha256 as digestEvidence } from "./domain/evidence-hash.js";
 export async function commitStagedRun(io, home, runId, port, options) {
     const assembled = await assembleStagedCommit(io, home, runId, port, {
@@ -17,7 +16,6 @@ export async function commitStagedRun(io, home, runId, port, options) {
     if (await options.isBlocked?.(assembled.plan.target) === true) {
         return { ok: false, message: 'target is blocked by curator: ' + assembled.plan.target, plan: assembled.plan };
     }
-    const journal = { runId, target: assembled.plan.target, create: !assembled.plan.targetExists, sources: assembled.plan.sources, phase: 'prepared', updatedAt: new Date(options.now()).toISOString() };
     let result;
     let evidenceSha256;
     let warning;
@@ -29,22 +27,12 @@ export async function commitStagedRun(io, home, runId, port, options) {
         // P1-6: the unit's run identity is the canonical parent run, not the stage key.
         const unitRunId = options.parentRunId ?? runId;
         const unitPlan = { runId: unitRunId, pairKey: pairKey(assembled.plan.target, first), target: assembled.plan.target, targetExists: assembled.plan.targetExists, sources: assembled.plan.sources, body: assembled.plan.body, supportFiles: assembled.plan.supportFiles, expectedTargetBody: assembled.plan.expectedTargetBody, expectedSourceBodies: assembled.plan.expectedSourceBodies, origin: options.origin, summary: options.summary, ...(options.limits === undefined ? {} : { skillLimits: options.limits }), ...(options.validationPlan === undefined ? {} : { validationPlan: options.validationPlan }), ...(options.targetRevision === undefined ? {} : { targetRevision: options.targetRevision }), ...(options.sourceRevisions === undefined ? {} : { sourceRevisions: options.sourceRevisions }), ...(options.supportDigest === undefined ? {} : { supportDigest: options.supportDigest }) };
-        try {
-            await writeJournal(io, home, journal);
-        }
-        catch { /* compat mirror; unit journal is authority */ }
         const prepared = await transaction.prepare(unitPlan);
         if (!prepared.ok)
             return { ok: false, message: prepared.message, plan: assembled.plan };
         const committed = await transaction.commit(prepared.prepared, options.signal === undefined ? undefined : { signal: options.signal });
-        if (!committed.ok) {
-            try {
-                await writeJournal(io, home, { ...journal, phase: 'failed', updatedAt: new Date(options.now()).toISOString() });
-            }
-            catch { }
-            ;
+        if (!committed.ok)
             return { ok: false, message: committed.message, plan: assembled.plan, ...(committed.code === 'target-changed' || committed.code === 'source-changed' || committed.code === 'support-changed' ? { code: committed.code } : {}) };
-        }
         const unitId = committed.evidence.unitId;
         if (committed.evidence.unitId !== prepared.prepared.unitId && !prepared.prepared.unitId.startsWith('legacy:'))
             return { ok: false, message: 'unit evidence does not match prepared unitId', plan: assembled.plan };
@@ -60,17 +48,8 @@ export async function commitStagedRun(io, home, runId, port, options) {
         result = { ok: true, message: 'merged', unitId, archived: committed.evidence.sources.filter(source => source.archived).map(source => source.name), mutations: committed.evidence.mutations };
     }
     if (!result.ok) {
-        try {
-            await writeJournal(io, home, { ...journal, phase: 'failed', updatedAt: new Date(options.now()).toISOString() });
-        }
-        catch { }
         return { ok: false, message: result.message, plan: assembled.plan };
     }
-    const committed = { ...journal, phase: 'committed', updatedAt: new Date(options.now()).toISOString(), ...(result.unitId === undefined ? {} : { unitId: result.unitId }) };
-    try {
-        await writeJournal(io, home, committed);
-    }
-    catch { }
     if (result.unitId === undefined)
         return { ok: true, plan: assembled.plan, result, warning: 'commit landed without a unitId; receipt not written' };
     const receipt = {

package/lib/types/contracts.d.ts

@@ -10,7 +10,6 @@ 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[];
-export declare const MERGE_QUEUES: readonly MergeQueue[];
 /** User-facing queue of one data state. verify/fuse share retry, not two tabs. */
 export declare function queueOf(state: MergePairState): MergeQueue;
 /** Coarse stage chip; skipped has no active stage. */

package/lib/types/contracts.js

@@ -6,7 +6,6 @@
  */
 export const MERGE_STATE_VERSION = 3;
 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) {

package/lib/types/doctor.d.ts

@@ -1,7 +1,6 @@
 import { type EvolutionIoLike } from '@lmzhen/dsh-evolution-core';
 import { type ReconcileReport } from './domain/reconcile.ts';
 import type { DoctorView } from './wire.ts';
-export declare const MERGE_DOCTOR_SCHEMA_VERSION = 3;
 /** The global doctor's merge line; built from the DoctorView envelope, never from raw files. */
 export interface MergeDoctorFact {
     readonly status: 'ok' | 'warn' | 'fail' | 'unknown';

package/lib/types/doctor.js

@@ -12,11 +12,9 @@ import { readUnitJournal } from '@lmzhen/dsh-evolution-core/write';
 import { migrationJournalPath, migrationReportPath, v2BackupPath } from "./domain/state-bootstrap.js";
 import { readMergeSnapshot } from "./domain/merge-snapshot.js";
 import { validateArtifacts } from "./domain/consistency.js";
-import { readJournal } from "./domain/commit-journal-store.js";
 import { readCommitReceipt } from "./commit-receipt.js";
 import { stagingRoot } from "./staging.js";
 import { readReconcileReport } from "./domain/reconcile.js";
-export const MERGE_DOCTOR_SCHEMA_VERSION = 3;
 /** Compose the one-line global-doctor fact from buildDoctorView + the last reconcile report. */
 export function mergeDoctorFact(view, report) {
     const counts = view.counts;
@@ -65,15 +63,6 @@ export async function mergeDoctor(io, home, configuredRoot) {
         status: snapshot.blocked === undefined || !hasState ? 'ok' : 'warn',
         detail: snapshot.blocked === undefined ? 'pairs ' + String(snapshot.rows.length) + '；verify ' + String(counts.verify) + ' / pending ' + String(counts.pending) + ' / fuse ' + String(counts.fuse) + ' / skipped ' + String(counts.skipped) + ' / expired ' + String(snapshot.doctor.counts.expired) : snapshot.blocked.code + ': ' + snapshot.blocked.message,
     });
-    const recoveryRuns = new Set();
-    try {
-        const raw = await io.readText(join(home, 'merge', 'recovery.json'));
-        if (raw !== null)
-            for (const report of JSON.parse(raw))
-                if (report.ok === true && report.runId !== undefined)
-                    recoveryRuns.add(report.runId);
-    }
-    catch { }
     const invalid = [];
     if (snapshot.blocked !== undefined)
         invalid.push({ id: 'state', reason: snapshot.blocked.code });
@@ -84,10 +73,10 @@ export async function mergeDoctor(io, home, configuredRoot) {
         const run = runId === undefined ? 'none' : row.state === 'pending' ? 'awaiting-approval' : 'running';
         const staging = item.stage === null ? (row.state === 'fuse' ? 'missing' : 'none') : item.stage.state === 'present' || item.stage.state === 'reserved' ? 'kept' : row.state === 'fuse' ? 'missing' : 'none';
         const receipt = runId === undefined ? null : await readCommitReceipt(io, home, runId);
-        const phase = receipt !== null ? await readUnitJournal(io, home, receipt.unitId) : runId === undefined ? null : await readJournal(io, home, runId);
+        const phase = receipt === null ? null : await readUnitJournal(io, home, receipt.unitId);
         const journal = phase === null ? 'none' : phase.phase === 'prepared' || phase.phase === 'target-pending' ? 'prepared' : phase.phase === 'target-written' || phase.phase === 'sources-archived' || phase.phase === 'support-pending' || phase.phase === 'source-archiving' ? 'committing' : phase.phase === 'committed' ? 'committed' : phase.phase === 'rolled-back' ? 'rolled-back' : 'failed';
         const evidence = receipt === null ? 'none' : 'receipt';
-        const result = validateArtifacts({ row: artifactRow, run, staging, journal, evidence, activeRuns: run === 'running' || run === 'awaiting-approval' ? 1 : 0, ...(runId !== undefined && recoveryRuns.has(runId) ? { recovery: true } : {}) });
+        const result = validateArtifacts({ row: artifactRow, run, staging, journal, evidence, activeRuns: run === 'running' || run === 'awaiting-approval' ? 1 : 0 });
         if (!result.ok)
             invalid.push({ id: row.id, reason: result.reason ?? 'not-allowed' });
     }
@@ -179,24 +168,6 @@ export async function mergeDoctor(io, home, configuredRoot) {
         status: 'ok',
         detail: stagingRoot(home, '<runId>'),
     });
-    try {
-        const raw = await io.readText(join(home, 'merge', 'recovery.json'));
-        if (raw !== null) {
-            const reports = JSON.parse(raw);
-            const failed = reports.filter(report => report.ok !== true);
-            rows.push({
-                key: 'recovery',
-                label: '提交恢复',
-                status: failed.length === 0 ? 'ok' : 'warn',
-                detail: failed.length === 0
-                    ? String(reports.length) + ' 条恢复报告，无待处理'
-                    : String(failed.length) + ' 条待处理：' + failed.map(report => (report.runId ?? '?') + '=' + (report.action ?? '?')).join(', '),
-            });
-        }
-    }
-    catch {
-        rows.push({ key: 'recovery', label: '提交恢复', status: 'unknown', detail: '无法读取 merge/recovery.json' });
-    }
     return rows;
 }
 //# sourceMappingURL=doctor.js.map

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

@@ -12,7 +12,6 @@ export interface ArtifactState {
     readonly evidence: EvidenceState;
     readonly activeRuns: number;
     readonly hasOwner?: boolean;
-    readonly recovery?: boolean;
 }
 export interface ConsistencyResult {
     readonly ok: boolean;

package/lib/types/domain/consistency.js

@@ -10,14 +10,6 @@ const ALLOWED = [
     { row: 'fuse', run: 'running', staging: 'kept', journal: 'none', evidence: 'none', activeRuns: 1 },
     { row: 'fuse', run: 'failed', staging: 'kept', journal: 'none', evidence: 'none', activeRuns: 0 },
     { row: 'fuse', run: 'orphan', staging: 'kept', journal: 'none', evidence: 'none', activeRuns: 0 },
-    { row: 'fuse', run: 'none', staging: 'none', journal: 'none', evidence: 'none', activeRuns: 0, recovery: true },
-    { row: 'fuse', run: 'failed', staging: 'none', journal: 'none', evidence: 'none', activeRuns: 0, recovery: true },
-    { row: 'fuse', run: 'orphan', staging: 'none', journal: 'none', evidence: 'none', activeRuns: 0, recovery: true },
-    { row: 'fuse', run: 'running', staging: 'none', journal: 'none', evidence: 'none', activeRuns: 1, recovery: true },
-    { row: 'fuse', run: 'none', staging: 'missing', journal: 'none', evidence: 'none', activeRuns: 0, recovery: true },
-    { row: 'fuse', run: 'failed', staging: 'missing', journal: 'none', evidence: 'none', activeRuns: 0, recovery: true },
-    { row: 'fuse', run: 'orphan', staging: 'missing', journal: 'none', evidence: 'none', activeRuns: 0, recovery: true },
-    { row: 'fuse', run: 'running', staging: 'missing', journal: 'none', evidence: 'none', activeRuns: 1, recovery: true },
     { row: 'fuse', run: 'running', staging: 'kept', journal: 'committing', evidence: 'none', activeRuns: 1 },
     { row: 'skipped', run: 'none', staging: 'none', journal: 'none', evidence: 'none', activeRuns: 0 },
     { row: 'merged', run: 'succeeded', staging: 'cleaned', journal: 'committed', evidence: 'receipt', activeRuns: 0 },
@@ -25,8 +17,7 @@ const ALLOWED = [
 ];
 function same(a, b) {
     return a.row === b.row && a.run === b.run && a.staging === b.staging && a.journal === b.journal
-        && a.evidence === b.evidence && a.activeRuns === b.activeRuns
-        && (b.recovery ?? false) === (a.recovery ?? false);
+        && a.evidence === b.evidence && a.activeRuns === b.activeRuns;
 }
 export function validateArtifacts(state) {
     if (state.activeRuns > 1)
@@ -39,7 +30,7 @@ export function validateArtifacts(state) {
         return { ok: false, reason: 'pending-staging' };
     if (state.row === 'skipped' && state.run === 'running')
         return { ok: false, reason: 'skipped-running' };
-    if (state.row === 'fuse' && state.staging === 'missing' && state.recovery !== true)
+    if (state.row === 'fuse' && state.staging === 'missing')
         return { ok: false, reason: 'fuse-lost-staging' };
     if (state.journal === 'committed' && state.evidence !== 'receipt')
         return { ok: false, reason: 'committed-no-evidence' };

package/lib/types/domain/merge-limits.d.ts

@@ -5,14 +5,4 @@ export interface MergeLimitsSnapshot {
 }
 export declare function resolveLimitsSnapshot(policy?: Parameters<typeof policyStageLimits>[0]): MergeLimitsSnapshot;
 export declare function limitsSnapshotOf(skillLimits: SkillLimits): MergeLimitsSnapshot;
-export declare function mergeLimitFinding(path: string, limit: string, observed: number, limitValue: number): {
-    readonly rule: string;
-    readonly path: string;
-    readonly severity: 'block';
-    readonly code: 'limit';
-    readonly limit: string;
-    readonly observed: number;
-    readonly limitValue: number;
-    readonly message: string;
-};
 //# sourceMappingURL=merge-limits.d.ts.map

package/lib/types/domain/merge-limits.js

@@ -16,7 +16,4 @@ export function resolveLimitsSnapshot(policy) {
 export function limitsSnapshotOf(skillLimits) {
     return { skillLimits, limitsDigest: createHash('sha256').update(canonical(skillLimits)).digest('hex') };
 }
-export function mergeLimitFinding(path, limit, observed, limitValue) {
-    return { rule: 'limit', path, severity: 'block', code: 'limit', limit, observed, limitValue, message: path + ' exceeds ' + limit + ' (' + String(observed) + ' > ' + String(limitValue) + ')' };
-}
 //# sourceMappingURL=merge-limits.js.map

package/lib/types/domain/merge-snapshot.js

@@ -4,7 +4,6 @@ import { readV4Readiness } from "./schema4.js";
 import { readPairLedgerV4 } from "./pair-ledger.js";
 import { readAllStages } from "./stage-aggregate.js";
 import { readRunMeta } from "./run-coordinator.js";
-import { loadPairIndex } from "./pair-index-store.js";
 import { mergeReportPath, readMergeReport } from "../report.js";
 import { readCommitReceipts } from "../commit-receipt.js";
 import { pendingExpiry, persistedExpiry } from "./live-facts.js";
@@ -41,14 +40,13 @@ export async function readMergeSnapshot(options) {
         rows.push({ row, stage, bodies, queue, expired: expiredKind !== null, ...(expiredKind === null ? {} : { expiredKind }) });
         bodyRefs.push(...bodies);
     }
-    const pairIndex = await loadPairIndex(options.io, options.home);
     const runs = [];
     for (const record of options.runs) {
         const meta = await readRunMeta(options.io, options.home, record.id);
-        const pairs = [...pairIndex.values()].filter(item => item.runId === record.id).map(item => ({ pairKey: item.pairKey, runId: item.runId, result: item.result, ...(item.target === undefined ? {} : { target: item.target }) }));
         const reportPath = mergeReportPath(options.home, record.id);
         const probe = await readMergeReport(options.io, options.home, record.id);
         const report = probe.kind === 'present' ? probe.value : null;
+        const pairs = (report?.pairs ?? []).map(pair => ({ pairKey: pair.pairKey, runId: record.id, result: pair.outcome, ...(pair.target === undefined ? {} : { target: pair.target.requested }) }));
         runs.push({ record, meta, pairs, report, reportRef: report === null ? null : reportPath });
     }
     const reports = runs.filter(run => run.report !== null).map(run => ({ runId: run.record.id, path: run.reportRef, report: run.report }));
@@ -70,10 +68,10 @@ export async function readMergeSnapshot(options) {
     const notes = [...(options.notes ?? [])];
     if (historyDegraded)
         notes.push('history archive port unavailable; receipts only');
-    const ledgerConflicts = [...pairIndex.values()].filter(entry => (entry.result === 'merged' || entry.result === 'undone')
-        && rows.some(item => item.row.pairKey === entry.pairKey && (item.row.state === 'verify' || item.row.state === 'pending' || item.row.state === 'approved' || item.row.state === 'fuse')));
+    const activePairKeys = new Set(rows.filter(item => item.row.state === 'verify' || item.row.state === 'pending' || item.row.state === 'approved' || item.row.state === 'fuse').map(item => item.row.pairKey));
+    const ledgerConflicts = runs.flatMap(run => run.pairs).filter(entry => (entry.result === 'merged' || entry.result === 'undone') && activePairKeys.has(entry.pairKey));
     if (ledgerConflicts.length > 0)
-        notes.push('ledger-conflict: pair-index says completed but the ledger still has it active (' + String(ledgerConflicts.length) + ')');
+        notes.push('ledger-conflict: a run says completed but the ledger still has it active (' + String(ledgerConflicts.length) + ')');
     return { wireVersion: 1, schemaVersion: 4, readAt, queueRevision, consistency: 'eventual', ...(hostOnly === undefined ? {} : { hostOnly }), rows, stages, runs, reports, report: reports.at(-1)?.report ?? null, history, bodyRefs, doctor, approval: { mergeApproval: options.approval, ...(options.platformWrite === undefined ? {} : { platformWrite: options.platformWrite }) }, notes, degraded: notes.length > 0 };
 }
 async function readHistory(io, home) {

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

@@ -2,7 +2,6 @@ import type { EvolutionIoLike } from '@lmzhen/dsh-evolution-core';
 import type { V4Row } from './row-v4.ts';
 import { type V3Row } from './row-v3.ts';
 import { type V4RowTx } from './schema4.ts';
-export type PairRow = V3Row;
 export interface PairLedgerRead {
     readonly schemaVersion: 3;
     readonly ledgerVersion?: number;

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

@@ -63,51 +63,6 @@ export interface SkippedRowV3 extends RowBaseV3 {
     readonly attempts: number;
 }
 export type V3Row = VerifyRowV3 | PendingRowV3 | ApprovedRowV3 | FuseRowV3 | SkippedRowV3;
-export type V3Event = {
-    readonly type: 'verify-passed';
-    readonly decision: MergeDecision;
-    readonly target: string;
-    readonly sourceRevision?: string;
-} | {
-    readonly type: 'approved';
-    readonly runId: string;
-} | {
-    readonly type: 'auto-approved';
-    readonly decision: MergeDecision;
-    readonly target: string;
-    readonly runId?: string;
-} | {
-    readonly type: 'staged';
-    readonly ref?: string;
-    readonly expiresAt?: number;
-} | {
-    readonly type: 'committed';
-    readonly unitId: string;
-} | {
-    readonly type: 'skipped';
-    readonly reason: string;
-    readonly origin?: 'agent' | 'human' | 'system';
-} | {
-    readonly type: 'expired';
-    readonly kind: 'target-taken' | 'source-changed';
-} | {
-    readonly type: 'failed';
-    readonly failure: MergeFailure;
-} | {
-    readonly type: 'restored';
-} | {
-    readonly type: 'superseded';
-};
-export type V3Transition = {
-    readonly ok: true;
-    readonly row: V3Row | null;
-    readonly version: number;
-} | {
-    readonly ok: false;
-    readonly code: 'version-conflict' | 'illegal-transition';
-    readonly message: string;
-};
-export declare function transitionV3(row: V3Row, event: V3Event, expectedVersion: number, at?: string): V3Transition;
 /** Runtime validation for a persisted v3 row. */
 export declare function isV3Row(value: unknown): value is V3Row;
 //# sourceMappingURL=row-v3.d.ts.map

package/lib/types/domain/row-v3.js

@@ -1,71 +1,3 @@
-function bad(code, message) { return { ok: false, code, message }; }
-function advance(row, at, patch) { return { ...row, ...patch, version: row.version + 1, updatedAt: at }; }
-export function transitionV3(row, event, expectedVersion, at = new Date().toISOString()) {
-    if (row.version !== expectedVersion)
-        return bad('version-conflict', 'expected ' + String(expectedVersion) + ', got ' + String(row.version));
-    switch (row.state) {
-        case 'verify':
-            if (event.type === 'verify-passed')
-                return { ok: true, row: advance(row, at, { state: 'pending', target: event.target, decision: event.decision, sourceRevision: event.sourceRevision, attempts: 0 }), version: expectedVersion + 1 };
-            if (event.type === 'auto-approved')
-                return { ok: true, row: advance(row, at, { state: 'approved', target: event.target, decision: event.decision, attempts: 0, ...(event.runId === undefined ? {} : { runId: event.runId }) }), version: expectedVersion + 1 };
-            if (event.type === 'failed')
-                return { ok: true, row: advance(row, at, { failure: event.failure, attempts: row.attempts + 1 }), version: expectedVersion + 1 };
-            if (event.type === 'skipped')
-                return { ok: true, row: advance(row, at, { state: 'skipped', reason: event.reason, attempts: row.attempts }), version: expectedVersion + 1 };
-            if (event.type === 'superseded')
-                return { ok: true, row: null, version: expectedVersion + 1 };
-            return bad('illegal-transition', 'verify/' + event.type);
-        case 'pending':
-            if (event.type === 'approved')
-                return { ok: true, row: advance(row, at, { state: 'approved', runId: event.runId }), version: expectedVersion + 1 };
-            if (event.type === 'auto-approved')
-                return { ok: true, row: advance(row, at, { state: 'approved', ...(event.runId === undefined ? {} : { runId: event.runId }) }), version: expectedVersion + 1 };
-            if (event.type === 'staged')
-                return { ok: true, row: advance(row, at, { state: 'fuse', staging: event.ref === undefined ? { kind: 'absent' } : { kind: 'present', ref: event.ref, expiresAt: event.expiresAt ?? Date.now() + 7 * 86_400_000 } }), version: expectedVersion + 1 };
-            if (event.type === 'skipped')
-                return { ok: true, row: advance(row, at, { state: 'skipped', reason: event.reason, ...(event.origin === undefined ? {} : { origin: event.origin }) }), version: expectedVersion + 1 };
-            if (event.type === 'expired')
-                return { ok: true, row: advance(row, at, { expired: event.kind }), version: expectedVersion + 1 };
-            if (event.type === 'failed')
-                return { ok: true, row: advance(row, at, { failure: event.failure, attempts: row.attempts + 1 }), version: expectedVersion + 1 };
-            if (event.type === 'superseded')
-                return { ok: true, row: null, version: expectedVersion + 1 };
-            return bad('illegal-transition', 'pending/' + event.type);
-        case 'approved':
-            if (event.type === 'staged')
-                return { ok: true, row: advance(row, at, { state: 'fuse', staging: event.ref === undefined ? { kind: 'absent' } : { kind: 'present', ref: event.ref, expiresAt: event.expiresAt ?? Date.now() + 7 * 86_400_000 } }), version: expectedVersion + 1 };
-            if (event.type === 'committed')
-                return { ok: true, row: null, version: expectedVersion + 1 };
-            if (event.type === 'skipped')
-                return { ok: true, row: advance(row, at, { state: 'skipped', reason: event.reason }), version: expectedVersion + 1 };
-            if (event.type === 'failed')
-                return event.failure.retryable
-                    ? { ok: true, row: advance(row, at, { state: 'pending', failure: event.failure, attempts: row.attempts + 1 }), version: expectedVersion + 1 }
-                    : { ok: true, row: advance(row, at, { state: 'skipped', reason: event.failure.code, failure: event.failure, attempts: row.attempts + 1 }), version: expectedVersion + 1 };
-            if (event.type === 'superseded')
-                return { ok: true, row: null, version: expectedVersion + 1 };
-            return bad('illegal-transition', 'approved/' + event.type);
-        case 'fuse':
-            if (event.type === 'staged')
-                return { ok: true, row: advance(row, at, { staging: event.ref === undefined ? { kind: 'absent' } : { kind: 'present', ref: event.ref, expiresAt: event.expiresAt ?? Date.now() + 7 * 86_400_000 } }), version: expectedVersion + 1 };
-            if (event.type === 'committed')
-                return { ok: true, row: null, version: expectedVersion + 1 };
-            if (event.type === 'skipped')
-                return { ok: true, row: advance(row, at, { state: 'skipped', reason: event.reason }), version: expectedVersion + 1 };
-            if (event.type === 'failed')
-                return event.failure.retryable
-                    ? { ok: true, row: advance(row, at, { state: 'pending', failure: event.failure, attempts: row.attempts + 1 }), version: expectedVersion + 1 }
-                    : { ok: true, row: advance(row, at, { state: 'skipped', reason: event.failure.code, failure: event.failure, attempts: row.attempts + 1 }), version: expectedVersion + 1 };
-            if (event.type === 'superseded')
-                return { ok: true, row: null, version: expectedVersion + 1 };
-            return bad('illegal-transition', 'fuse/' + event.type);
-        case 'skipped':
-            if (event.type === 'restored' || event.type === 'superseded')
-                return { ok: true, row: null, version: expectedVersion + 1 };
-            return bad('illegal-transition', 'skipped is terminal');
-    }
-}
 function object(value) { return value !== null && typeof value === 'object'; }
 function string(value) { return typeof value === 'string' && value.length > 0; }
 function number(value) { return typeof value === 'number' && Number.isFinite(value); }

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

@@ -1,4 +1,5 @@
-import { type MergeState } from './state.ts';
+/** The v2 row shape still read by the ledger/migration bridge. No IO. */
+import type { MergeState } from './state.ts';
 import type { MergeDecision, MergeFailure } from '../contracts.ts';
 export interface MergeRowV2 {
     readonly id: string;
@@ -28,87 +29,4 @@ export interface MergeRowV2 {
     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