@lmzhen/dsh-evolution-merge 0.47.0 → 0.48.0

package/lib/types/commit-recovery.js

@@ -1,96 +0,0 @@
-/** Startup replay for non-terminal commit journals: report only, never write skills. */
-import { join } from 'node:path';
-import { writeJournal } from "./domain/commit-journal-store.js";
-import { readCommitReceipt } from "./commit-receipt.js";
-import { readUnitEvidence } from '@lmzhen/dsh-evolution-core/write';
-export async function recoverCommitJournals(io, home, now, isActive) {
-    const dir = join(home, 'merge', 'journals');
-    const reports = [];
-    let files = [];
-    if (await io.exists(dir)) {
-        try {
-            files = (await io.list(dir)).filter(name => name.endsWith('.json'));
-        }
-        catch {
-            reports.push({ runId: '(list)', phase: 'unknown', action: 'journal-list-failed', ok: false, journalPath: dir });
-        }
-    }
-    for (const file of files) {
-        const path = join(dir, file);
-        try {
-            let journal;
-            try {
-                journal = JSON.parse(await io.readText(path) ?? '');
-            }
-            catch {
-                reports.push({ runId: file.replace(/\.json$/, ''), phase: 'unknown', action: 'journal-unreadable', ok: false, journalPath: path });
-                continue;
-            }
-            if (isActive?.(journal.runId) === true) {
-                reports.push({ runId: journal.runId, phase: journal.phase, action: 'skipped-active-run', ok: true, target: journal.target, sources: journal.sources, journalPath: path });
-                continue;
-            }
-            let receipt = null;
-            try {
-                receipt = await readCommitReceipt(io, home, journal.runId, journal.target);
-            }
-            catch {
-                reports.push({ runId: journal.runId, phase: journal.phase, action: 'receipt-read-failed', ok: false, target: journal.target, sources: journal.sources, journalPath: path });
-                continue;
-            }
-            if (receipt !== null) {
-                await writeJournal(io, home, { ...journal, phase: 'committed', unitId: receipt.unitId, updatedAt: new Date(now).toISOString() });
-                reports.push({ runId: journal.runId, phase: journal.phase, action: 'receipt-committed', ok: true, target: journal.target, sources: journal.sources, journalPath: path, unitId: receipt.unitId });
-                continue;
-            }
-            if (journal.phase === 'committed') {
-                reports.push({ runId: journal.runId, phase: journal.phase, action: 'receipt-missing', ok: false, target: journal.target, sources: journal.sources, journalPath: path });
-                continue;
-            }
-            if (journal.phase === 'failed' || journal.phase === 'rolled-back')
-                continue;
-            reports.push({
-                runId: journal.runId, phase: journal.phase, action: 'manual-required', ok: false,
-                target: journal.target, sources: journal.sources, journalPath: path,
-            });
-        }
-        catch (error) {
-            reports.push({ runId: file.replace(/\.json$/, ''), phase: 'unknown', action: 'recovery-error: ' + (error instanceof Error ? error.message : String(error)), ok: false, journalPath: path });
-        }
-    }
-    const unitDir = join(home, 'merge', 'unit-journals');
-    if (await io.exists(unitDir)) {
-        let unitFiles = [];
-        try {
-            unitFiles = (await io.list(unitDir)).filter(name => name.endsWith('.json'));
-        }
-        catch { /* no unit journals */ }
-        for (const file of unitFiles) {
-            const path = join(unitDir, file);
-            try {
-                const journal = JSON.parse(await io.readText(path) ?? '');
-                const evidence = await readUnitEvidence(io, home, journal.unitId);
-                if (evidence !== null) {
-                    reports.push({ runId: journal.runId, phase: 'committed', action: 'unit-committed', ok: true, target: journal.target, sources: journal.sources, journalPath: path, unitId: journal.unitId });
-                    continue;
-                }
-                if (journal.phase === 'committed') {
-                    reports.push({ runId: journal.runId, phase: 'committed', action: 'unit-evidence-missing', ok: false, target: journal.target, sources: journal.sources, journalPath: path, unitId: journal.unitId });
-                    continue;
-                }
-                if (journal.phase === 'failed' || journal.phase === 'rolled-back')
-                    continue;
-                reports.push({ runId: journal.runId, phase: journal.phase, action: 'unit-manual-required', ok: false, target: journal.target, sources: journal.sources, journalPath: path, unitId: journal.unitId });
-            }
-            catch {
-                reports.push({ runId: '(unit)', phase: 'unknown', action: 'unit-journal-unreadable', ok: false, journalPath: path });
-            }
-        }
-    }
-    try {
-        await io.writeText(join(home, 'merge', 'recovery.json'), JSON.stringify(reports, null, 2));
-    }
-    catch { /* report file is best-effort; reports are still returned */ }
-    return reports;
-}
-//# sourceMappingURL=commit-recovery.js.map

package/lib/types/coordinator.d.ts

@@ -1,77 +0,0 @@
-/**
- * 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 one state transaction. Invalid transitions are refused by name;
- * a caller never "repairs" a row by guessing which state the operator meant.
- */
-import { type MergeDecision, type MergeFailure, type MergeRow } from './contracts.ts';
-export type MergeEvent = {
-    readonly type: 'candidate';
-    readonly a: string;
-    readonly b: string;
-    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 sourceRevision?: string;
-    readonly targetRevision?: string;
-    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-fail';
-    readonly failure: MergeFailure;
-    readonly at: string;
-} | {
-    readonly type: 'round2-cancel';
-    readonly at: string;
-} | {
-    readonly type: 'round2-success';
-    readonly unitId?: string;
-    readonly at: string;
-} | {
-    readonly type: 'restore';
-    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: 'gate-keep';
-    readonly a: string;
-    readonly b: string;
-    readonly reason?: string;
-    readonly at: string;
-};
-export type TransitionResult = {
-    readonly ok: true;
-    readonly row: MergeRow | null;
-} | {
-    readonly ok: false;
-    readonly code: 'invalid-transition';
-    readonly message: string;
-};
-/** Legacy v2 projection only; runtime writes must use transitionV3/RowTx. */
-export declare function transitionLegacyForProjection(current: MergeRow | undefined, event: MergeEvent): TransitionResult;
-//# sourceMappingURL=coordinator.d.ts.map

package/lib/types/coordinator.js

@@ -1,137 +0,0 @@
-/**
- * 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 one state 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,
-        },
-    };
-}
-/** Legacy v2 projection only; runtime writes must use transitionV3/RowTx. */
-export function transitionLegacyForProjection(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 }), ...(event.sourceRevision === undefined ? {} : { sourceRevision: event.sourceRevision }), ...(event.targetRevision === undefined ? {} : { targetRevision: event.targetRevision }) })
-                : next(current, event.at, 'approved', { ...(event.decision === undefined ? {} : { decision: event.decision }), ...(event.stagingRef === undefined ? {} : { stagingRef: event.stagingRef }), ...(event.stagingExpiresAt === undefined ? {} : { stagingExpiresAt: event.stagingExpiresAt }), ...(event.sourceRevision === undefined ? {} : { sourceRevision: event.sourceRevision }), ...(event.targetRevision === undefined ? {} : { targetRevision: event.targetRevision }) });
-        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 'target-taken':
-        case '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);
-        case 'restore':
-            return current.state === 'skipped'
-                ? next(current, event.at, 'verify')
-                : invalid(event, current.state);
-    }
-}
-//# sourceMappingURL=coordinator.js.map

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

@@ -1,6 +0,0 @@
-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

@@ -1,26 +0,0 @@
-/** 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);
-    const content = JSON.stringify(journal, null, 2);
-    if (io.transact !== undefined)
-        await io.transact(path, () => content);
-    else
-        await io.writeText(path, content);
-    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

@@ -1,16 +0,0 @@
-/** 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' | 'refuse';
-/** 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

@@ -1,26 +0,0 @@
-const NEXT = {
-    prepared: ['committed', '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';
-        default: return 'refuse';
-    }
-}
-//# sourceMappingURL=commit-journal.js.map

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

@@ -1,21 +0,0 @@
-/** 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

@@ -1,15 +0,0 @@
-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/merge-report.d.ts

@@ -1,41 +0,0 @@
-/** 1b-1 additive report schema; values are filled by later batches. */
-export interface MergeReportLimits {
-    readonly maxSkillFileBytes?: number;
-    readonly maxTokenBytes?: number;
-    readonly pairTimeoutMinutes?: number;
-}
-export interface MergeReportValidation {
-    readonly ok: boolean;
-    readonly errors: readonly string[];
-}
-export interface MergeReport {
-    readonly schemaVersion: 2;
-    readonly reportId: string;
-    readonly runId: string;
-    readonly pairKey: string;
-    readonly target: string;
-    readonly sourceRevisions?: Readonly<Record<string, string>>;
-    readonly targetRevision?: string;
-    readonly validation: MergeReportValidation;
-    readonly limits: MergeReportLimits;
-    readonly q09?: {
-        readonly forwardRefs: readonly string[];
-        readonly reverseRefs: readonly string[];
-        readonly orphanFiles: readonly string[];
-    };
-    readonly threat?: {
-        readonly body: string;
-        readonly source: string;
-    };
-    readonly createdAt: string;
-}
-export interface MergeReportRef {
-    readonly path: string;
-    readonly digest: string;
-    readonly writtenAt: string;
-}
-export interface MergeReportWriter {
-    write(report: MergeReport): Promise<MergeReportRef>;
-    read(runId: string): Promise<MergeReport | null>;
-}
-//# sourceMappingURL=merge-report.d.ts.map

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

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=merge-report.js.map

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

@@ -1,6 +0,0 @@
-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

@@ -1,25 +0,0 @@
-/** 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

@@ -1,9 +0,0 @@
-/** 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

@@ -1,28 +0,0 @@
-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

@@ -1,4 +0,0 @@
-/** Pure pair-index lookup. No run-record merge fields. */
-import type { PairIndexEntryV2 } from './indexes.ts';
-export declare function findPairRun(pairs: readonly PairIndexEntryV2[], pairKey: string): PairIndexEntryV2 | undefined;
-//# sourceMappingURL=resolve-pair.d.ts.map

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

@@ -1,4 +0,0 @@
-export function findPairRun(pairs, pairKey) {
-    return pairs.find(entry => entry.pairKey === pairKey);
-}
-//# sourceMappingURL=resolve-pair.js.map

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

@@ -1,27 +0,0 @@
-/** G3-5 RowTx pure write API: only createVerify/createSkipped/transition. */
-import { type SkippedRowV3, type V3Event, type V3Row, type VerifyRowV3 } from './row-v3.ts';
-export type RowWrite = {
-    readonly kind: 'createVerify';
-    readonly row: VerifyRowV3;
-} | {
-    readonly kind: 'createSkipped';
-    readonly row: SkippedRowV3;
-} | {
-    readonly kind: 'transition';
-    readonly id: string;
-    readonly event: V3Event;
-    readonly expectedVersion: number;
-};
-type RowWriteErrorCode = 'row-invalid' | 'row-duplicate' | 'row-not-found' | 'version-conflict' | 'illegal-transition';
-export type RowWriteResult = {
-    readonly ok: true;
-    readonly rows: readonly V3Row[];
-    readonly row: V3Row | null;
-} | {
-    readonly ok: false;
-    readonly code: RowWriteErrorCode;
-    readonly message: string;
-};
-export declare function applyRowWrite(rows: readonly V3Row[], write: RowWrite, at: string): RowWriteResult;
-export {};
-//# sourceMappingURL=row-tx.d.ts.map

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

@@ -1,31 +0,0 @@
-/** G3-5 RowTx pure write API: only createVerify/createSkipped/transition. */
-import { isV3Row, transitionV3 } from "./row-v3.js";
-function bad(code, message) { return { ok: false, code, message }; }
-export function applyRowWrite(rows, write, at) {
-    if (write.kind === 'transition') {
-        const index = rows.findIndex(row => row.id === write.id);
-        if (index < 0)
-            return bad('row-not-found', 'row not found: ' + write.id);
-        const current = rows[index];
-        const moved = transitionV3(current, write.event, write.expectedVersion, at);
-        if (!moved.ok)
-            return bad(moved.code, moved.message);
-        if (moved.row === null)
-            return { ok: true, rows: rows.filter((_, atIndex) => atIndex !== index), row: null };
-        const next = [...rows];
-        next[index] = moved.row;
-        return { ok: true, rows: next, row: moved.row };
-    }
-    if (write.row.version !== 0)
-        return bad('row-invalid', 'create requires version 0');
-    if (write.kind === 'createVerify' && (write.row.state !== 'verify' || write.row.verifySubState !== 'unverified'))
-        return bad('row-invalid', 'createVerify requires verify/unverified');
-    if (write.kind === 'createSkipped' && write.row.state !== 'skipped')
-        return bad('row-invalid', 'createSkipped requires skipped');
-    if (!isV3Row(write.row))
-        return bad('row-invalid', 'created row is invalid');
-    if (rows.some(row => row.id === write.row.id))
-        return bad('row-duplicate', 'duplicate row id: ' + write.row.id);
-    return { ok: true, rows: [...rows, write.row], row: write.row };
-}
-//# sourceMappingURL=row-tx.js.map