ushman-ledger 0.3.0 → 1.2.0

package/dist/schema/entry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"entry.d.ts","sourceRoot":"","sources":["../../src/schema/entry.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"entry.d.ts","sourceRoot":"","sources":["../../src/schema/entry.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,WAAW,EAAqB,MAAM,iBAAiB,CAAC;AACtE,OAAO,EAAE,KAAK,YAAY,EAAsB,MAAM,kBAAkB,CAAC;AAEzE,cAAc,iBAAiB,CAAC;AAChC,cAAc,uBAAuB,CAAC;AACtC,cAAc,iBAAiB,CAAC;AAChC,cAAc,kBAAkB,CAAC;AAEjC,eAAO,MAAM,gBAAgB,GAAI,OAAO,OAAO,KAAG,WAAyE,CAAC;AAE5H,eAAO,MAAM,iBAAiB,GAAI,OAAO,OAAO,KAAG,YACa,CAAC"}

package/dist/schema/entry.js

@@ -1,619 +1,10 @@
-import path from 'node:path';
-import { z } from 'zod';
-import { createDeterministicUuidV7, isUuidV7 } from "../uuid.js";
-import { NoteSubkindSchema } from "./note.js";
-export const LedgerSchemaVersion = 'ushman-ledger-entry/v1';
-export const LEDGER_PHASES = [
-    'capture',
-    'intake',
-    'seed',
-    'vendor-extract',
-    'cleanup',
-    'parity',
-    'characterize',
-    'equiv',
-    'analyze',
-    'recover',
-    'ship',
-    'migration',
-];
-export const LEDGER_KINDS = [
-    'tool-invocation',
-    'agent-patch',
-    'operator-patch',
-    'stage-transition',
-    'operator-decision',
-    'validator-result',
-    'runtime-event',
-    'note',
-    'correction',
-    'strip-decision-reverted',
-    'descope-brief',
-    'merge-return',
-    'merge-return-rejected',
-    'revert',
-    'rollback',
-    'rework.test_retired',
-];
-export const STAGE_TRANSITION_STAGES = [
-    'intake',
-    'seed',
-    'vendor-extract',
-    'cleanup',
-    'parity',
-    'characterize',
-];
-export const OPERATOR_DECISION_ACTIONS = [
-    'bypass-doctor',
-    'skip-check',
-    'override-strip-decision',
-    'override-ship-state',
-    'manual-parity-assertion',
-    'ledger-hand-edit',
-    'escalation',
-];
-const SHA256_HEX_PATTERN = /^[a-f0-9]{64}$/u;
-const WINDOWS_ABSOLUTE_PATH_PATTERN = /^[a-z]:[\\/]/iu;
-const normalizeWorkspaceRelativePath = (value) => value.replaceAll('\\', '/');
-const mergeAffectedFiles = (left, right) => [
-    ...new Set([...(left ?? []), ...right]),
-];
-const WorkspaceRelativePathSchema = z
-    .string()
-    .min(1)
-    .refine((value) => {
-    const normalized = normalizeWorkspaceRelativePath(value);
-    if (normalized.startsWith('/') || WINDOWS_ABSOLUTE_PATH_PATTERN.test(value)) {
-        return false;
-    }
-    if (normalized.startsWith('./') ||
-        normalized.endsWith('/') ||
-        normalized.includes('//') ||
-        normalized === '.' ||
-        normalized === '..') {
-        return false;
-    }
-    if (path.posix.normalize(normalized) !== normalized) {
-        return false;
-    }
-    return !normalized.split('/').includes('..');
-}, 'Expected a normalized workspace-relative path.');
-const SHA256HexSchema = z.string().regex(SHA256_HEX_PATTERN, 'Expected a lowercase SHA-256 hex digest.');
-const UuidV7Schema = z.string().refine(isUuidV7, 'Expected a UUIDv7 value.');
-const LegacyOperatorDecisionTypeSchema = z.enum([
-    'strip-decision',
-    'strip-decision-revised',
-    'vendor-boundary',
-    'intent-exclusion',
-    'other',
-]);
-export const mapLegacyDecisionTypeToAction = (decisionType) => {
-    switch (decisionType) {
-        case 'strip-decision':
-        case 'strip-decision-revised':
-            return 'override-strip-decision';
-        default:
-            return 'escalation';
-    }
-};
-const makeDigestRecordSchema = () => z.record(z.string().min(1), SHA256HexSchema);
-const validatePatchPayload = ({ ctx, payload, }) => {
-    const touchedPaths = payload.touchedPaths ?? [];
-    const beforeMap = payload.fileSha256Before ?? {};
-    const afterMap = payload.fileSha256After ?? {};
-    if (touchedPaths.length === 0) {
-        ctx.addIssue({
-            code: 'custom',
-            message: 'payload.touchedPaths must contain at least one path',
-            path: ['payload', 'touchedPaths'],
-        });
-    }
-    for (const touchedPath of touchedPaths) {
-        if (!(touchedPath in beforeMap)) {
-            ctx.addIssue({
-                code: 'custom',
-                message: `payload.fileSha256Before is missing ${touchedPath}`,
-                path: ['payload', 'fileSha256Before', touchedPath],
-            });
-        }
-        if (!(touchedPath in afterMap)) {
-            ctx.addIssue({
-                code: 'custom',
-                message: `payload.fileSha256After is missing ${touchedPath}`,
-                path: ['payload', 'fileSha256After', touchedPath],
-            });
-        }
-    }
-    for (const hunk of payload.hunks ?? []) {
-        if (!touchedPaths.includes(hunk.path)) {
-            ctx.addIssue({
-                code: 'custom',
-                message: `payload.hunks path ${hunk.path} must appear in payload.touchedPaths`,
-                path: ['payload', 'hunks'],
-            });
-        }
-    }
-};
-export const LedgerPhaseSchema = z.enum(LEDGER_PHASES);
-export const StageTransitionStageSchema = z.enum(STAGE_TRANSITION_STAGES);
-export const OperatorDecisionActionSchema = z.enum(OPERATOR_DECISION_ACTIONS);
-export const EmitterSchema = z.object({
-    tool: z.string().min(1),
-    user: z.string().min(1).optional(),
-    version: z.string().min(1),
-});
-export const LedgerLinksSchema = z
-    .object({
-    affectedFiles: z.array(WorkspaceRelativePathSchema).optional(),
-    blobs: z.array(z.string()).optional(),
-    briefId: z.string().optional(),
-    correctsLedgerId: z.string().optional(),
-    gitRef: z.string().optional(),
-    idempotencyKey: z.string().optional(),
-    stripDecisionId: z.string().optional(),
-    supersedesLedgerId: z.string().optional(),
-    validatorVerdictId: z.string().optional(),
-})
-    .catchall(z.unknown());
-const LedgerEntryBaseSchema = z.object({
-    _legacy: z.literal(true).optional(),
-    details: z.record(z.string(), z.unknown()).optional(),
-    emitter: EmitterSchema,
-    id: z.string().min(1),
-    kind: z.string().min(1),
-    links: LedgerLinksSchema.default({}),
-    phase: LedgerPhaseSchema,
-    prevEntryId: z.string().min(1).nullable(),
-    schemaVersion: z.literal(LedgerSchemaVersion),
-    summary: z.string().min(1),
-    ts: z.string().datetime({ offset: true }),
-});
-export const PatchHunkSchema = z
-    .object({
-    endLine: z.number().int().positive(),
-    path: WorkspaceRelativePathSchema,
-    startLine: z.number().int().positive(),
-})
-    .refine((value) => value.endLine >= value.startLine, {
-    message: 'payload.hunks endLine must be greater than or equal to startLine',
-    path: ['endLine'],
-});
-export const PatchPayloadSchema = z.object({
-    diff: z.string().min(1).optional(),
-    diffSha256: SHA256HexSchema,
-    fileSha256After: makeDigestRecordSchema().default({}),
-    fileSha256Before: makeDigestRecordSchema().default({}),
-    hunks: z.array(PatchHunkSchema).default([]),
-    touchedPaths: z.array(WorkspaceRelativePathSchema).default([]),
-});
-export const PatchPayloadWriteSchema = PatchPayloadSchema.superRefine((value, ctx) => {
-    validatePatchPayload({
-        ctx,
-        payload: value,
-    });
-    if (!value.diff) {
-        ctx.addIssue({
-            code: 'custom',
-            message: 'payload.diff is required for new patch records',
-            path: ['diff'],
-        });
-    }
-});
-export const OperatorDecisionPayloadSchema = z.object({
-    action: OperatorDecisionActionSchema,
-    checkId: z.string().min(1).optional(),
-    rationale: z.string().trim().min(1, 'payload.rationale must not be empty'),
-});
-export const ValidatorResultPayloadSchema = z.object({
-    id: UuidV7Schema,
-});
-export const CorrectionPayloadSchema = z.object({
-    correctsValidatorResultId: UuidV7Schema.optional(),
-});
-export const StageTransitionPayloadSchema = z.object({
-    doctorBaselineId: z.string().min(1).optional(),
-    endedAt: z.string().datetime({ offset: true }),
-    exitCode: z.number().int(),
-    stage: StageTransitionStageSchema,
-    startedAt: z.string().datetime({ offset: true }),
-});
-export const StripDecisionRevertedPayloadSchema = z.object({
-    invalidatedStages: z.array(StageTransitionStageSchema).optional(),
-    rationale: z.string().trim().min(1),
-    stripDecisionId: z.string().min(1),
-});
-export const DescopeBriefPayloadSchema = z.object({
-    briefId: z.string().min(1),
-    reason: z.string().trim().min(1).optional(),
-    round: z.number().int().positive().optional(),
-    stripDecisionIds: z.array(z.string().min(1)).optional(),
-});
-export const MergeReturnPayloadSchema = z.object({
-    briefId: z.string().min(1).optional(),
-    returnId: z.string().min(1),
-    source: z.string().min(1).optional(),
-});
-export const MergeReturnRejectedPayloadSchema = MergeReturnPayloadSchema.extend({
-    reason: z.string().trim().min(1),
-});
-export const RevertPayloadSchema = z.object({
-    reason: z.string().trim().min(1),
-    targetEntryId: z.string().min(1).optional(),
-});
-export const RollbackPayloadSchema = RevertPayloadSchema.extend({
-    targetStage: StageTransitionStageSchema.optional(),
-});
-export const ReworkTestRetiredPayloadSchema = z.object({
-    briefId: z.string().min(1).optional(),
-    removedBy: z.enum(['descope', 'decompose', 'operator']),
-    removedTestPath: WorkspaceRelativePathSchema,
-    removedTestSymbols: z.array(z.string().min(1)),
-    sourceSymbolDeletedFrom: WorkspaceRelativePathSchema,
-});
-export const ToolInvocationEntrySchema = LedgerEntryBaseSchema.extend({
-    args: z.array(z.string()).optional(),
-    cwd: z.string().optional(),
-    exitCode: z.number().int().optional(),
-    kind: z.literal('tool-invocation'),
-});
-export const AgentPatchDiffSchema = z.object({
-    addedLines: z.number().int().nonnegative(),
-    blobSha256: SHA256HexSchema,
-    bytes: z.number().int().nonnegative(),
-    removedLines: z.number().int().nonnegative(),
-});
-const PatchEntryBaseSchema = LedgerEntryBaseSchema.extend({
-    diff: AgentPatchDiffSchema,
-    payload: PatchPayloadSchema,
-    rationale: z.string().min(1),
-}).superRefine((value, ctx) => {
-    if (value.payload.diffSha256 !== value.diff.blobSha256) {
-        ctx.addIssue({
-            code: 'custom',
-            message: 'payload.diffSha256 must match diff.blobSha256',
-            path: ['payload', 'diffSha256'],
-        });
-    }
-    validatePatchPayload({
-        ctx,
-        payload: value.payload,
-    });
-});
-export const AgentPatchEntrySchema = PatchEntryBaseSchema.safeExtend({
-    agent: z.object({
-        name: z.string().min(1),
-        sessionId: z.string().min(1).optional(),
-    }),
-    kind: z.literal('agent-patch'),
-});
-export const OperatorPatchEntrySchema = PatchEntryBaseSchema.safeExtend({
-    kind: z.literal('operator-patch'),
-    operator: z.object({
-        name: z.string().min(1),
-    }),
-});
-export const StageTransitionEntrySchema = LedgerEntryBaseSchema.extend({
-    kind: z.literal('stage-transition'),
-    payload: StageTransitionPayloadSchema,
-});
-export const OperatorDecisionEntrySchema = LedgerEntryBaseSchema.extend({
-    body: z.record(z.string(), z.unknown()).optional(),
-    decisionType: LegacyOperatorDecisionTypeSchema.optional(),
-    kind: z.literal('operator-decision'),
-    payload: OperatorDecisionPayloadSchema,
-});
-export const ValidatorResultEntrySchema = LedgerEntryBaseSchema.extend({
-    kind: z.literal('validator-result'),
-    metrics: z.record(z.string(), z.unknown()).optional(),
-    payload: ValidatorResultPayloadSchema,
-    resultPath: z.string().optional(),
-    validator: z.enum(['parity', 'equiv', 'characterize', 'verify', 'doctor']),
-    verdict: z.enum(['green', 'yellow', 'red']),
-});
-export const RuntimeEventEntrySchema = LedgerEntryBaseSchema.extend({
-    kind: z.literal('runtime-event'),
-    level: z.enum(['info', 'warn', 'error']),
-    message: z.string().min(1),
-    source: z.string().min(1),
-    stripDecisionId: z.string().optional(),
-});
-export const NoteEntrySchema = LedgerEntryBaseSchema.extend({
-    body: z.string(),
-    kind: z.literal('note'),
-    subkind: NoteSubkindSchema,
-});
-export const CorrectionEntrySchema = LedgerEntryBaseSchema.extend({
-    kind: z.literal('correction'),
-    payload: CorrectionPayloadSchema.default({}),
-    rationale: z.string().min(1),
-}).superRefine((value, ctx) => {
-    if (!value.links?.correctsLedgerId) {
-        ctx.addIssue({
-            code: 'custom',
-            message: 'correction entries require links.correctsLedgerId',
-            path: ['links', 'correctsLedgerId'],
-        });
-    }
-});
-export const StripDecisionRevertedEntrySchema = LedgerEntryBaseSchema.extend({
-    kind: z.literal('strip-decision-reverted'),
-    payload: StripDecisionRevertedPayloadSchema,
-});
-export const DescopeBriefEntrySchema = LedgerEntryBaseSchema.extend({
-    kind: z.literal('descope-brief'),
-    payload: DescopeBriefPayloadSchema,
-});
-export const MergeReturnEntrySchema = LedgerEntryBaseSchema.extend({
-    kind: z.literal('merge-return'),
-    payload: MergeReturnPayloadSchema,
-});
-export const MergeReturnRejectedEntrySchema = LedgerEntryBaseSchema.extend({
-    kind: z.literal('merge-return-rejected'),
-    payload: MergeReturnRejectedPayloadSchema,
-});
-export const RevertEntrySchema = LedgerEntryBaseSchema.extend({
-    kind: z.literal('revert'),
-    payload: RevertPayloadSchema,
-});
-export const RollbackEntrySchema = LedgerEntryBaseSchema.extend({
-    kind: z.literal('rollback'),
-    payload: RollbackPayloadSchema,
-});
-export const ReworkTestRetiredEntrySchema = LedgerEntryBaseSchema.extend({
-    kind: z.literal('rework.test_retired'),
-    payload: ReworkTestRetiredPayloadSchema,
-});
-export const LedgerEntrySchema = z.discriminatedUnion('kind', [
-    ToolInvocationEntrySchema,
-    AgentPatchEntrySchema,
-    OperatorPatchEntrySchema,
-    StageTransitionEntrySchema,
-    OperatorDecisionEntrySchema,
-    ValidatorResultEntrySchema,
-    RuntimeEventEntrySchema,
-    NoteEntrySchema,
-    CorrectionEntrySchema,
-    StripDecisionRevertedEntrySchema,
-    DescopeBriefEntrySchema,
-    MergeReturnEntrySchema,
-    MergeReturnRejectedEntrySchema,
-    RevertEntrySchema,
-    RollbackEntrySchema,
-    ReworkTestRetiredEntrySchema,
-]);
-const LegacyAgentPatchEntrySchema = LedgerEntryBaseSchema.extend({
-    agent: z.object({
-        name: z.string().min(1),
-        sessionId: z.string().min(1).optional(),
-    }),
-    diff: AgentPatchDiffSchema,
-    kind: z.literal('agent-patch'),
-    rationale: z.string().min(1),
-});
-const LegacyOperatorDecisionEntrySchema = LedgerEntryBaseSchema.extend({
-    body: z.record(z.string(), z.unknown()),
-    decisionType: LegacyOperatorDecisionTypeSchema,
-    kind: z.literal('operator-decision'),
-});
-const LegacyValidatorResultEntrySchema = LedgerEntryBaseSchema.extend({
-    kind: z.literal('validator-result'),
-    metrics: z.record(z.string(), z.unknown()).optional(),
-    resultPath: z.string().optional(),
-    validator: z.enum(['parity', 'equiv', 'characterize', 'verify', 'doctor']),
-    verdict: z.enum(['green', 'yellow', 'red']),
-});
-const RecordEntryBaseSchema = z.object({
-    details: z.record(z.string(), z.unknown()).optional(),
-    emitter: EmitterSchema,
-    idempotencyKey: z.string().min(1).optional(),
-    links: LedgerLinksSchema.optional(),
-    phase: LedgerPhaseSchema,
-    summary: z.string().min(1),
-});
-export const ToolInvocationRecordSchema = RecordEntryBaseSchema.extend({
-    args: z.array(z.string()).optional(),
-    cwd: z.string().optional(),
-    exitCode: z.number().int().optional(),
-    kind: z.literal('tool-invocation'),
-});
-const PatchRecordPayloadInputSchema = z.object({
-    diff: z.string().min(1).optional(),
-    diffSha256: SHA256HexSchema.optional(),
-    fileSha256After: makeDigestRecordSchema().optional(),
-    fileSha256Before: makeDigestRecordSchema().optional(),
-    hunks: z.array(PatchHunkSchema).optional(),
-    touchedPaths: z.array(WorkspaceRelativePathSchema).min(1).optional(),
-});
-const PatchRecordBaseSchema = RecordEntryBaseSchema.extend({
-    diff: AgentPatchDiffSchema.optional(),
-    diffPath: z.string().min(1).optional(),
-    payload: PatchRecordPayloadInputSchema.optional(),
-    rationale: z.string().min(1),
-}).superRefine((value, ctx) => {
-    if (!value.payload && !value.diff && !value.diffPath) {
-        ctx.addIssue({
-            code: 'custom',
-            message: 'patch records require payload, diff, or diffPath',
-            path: ['payload'],
-        });
-    }
-    if (value.diff && value.diffPath) {
-        ctx.addIssue({
-            code: 'custom',
-            message: 'patch records must provide either diff or diffPath, not both',
-            path: ['diffPath'],
-        });
-    }
-});
-export const AgentPatchRecordSchema = PatchRecordBaseSchema.safeExtend({
-    agent: z.object({
-        name: z.string().min(1),
-        sessionId: z.string().min(1).optional(),
-    }),
-    kind: z.literal('agent-patch'),
-});
-export const OperatorPatchRecordSchema = PatchRecordBaseSchema.safeExtend({
-    kind: z.literal('operator-patch'),
-    operator: z.object({
-        name: z.string().min(1),
-    }),
-});
-export const StageTransitionRecordSchema = RecordEntryBaseSchema.extend({
-    kind: z.literal('stage-transition'),
-    payload: StageTransitionPayloadSchema,
-});
-export const OperatorDecisionRecordSchema = RecordEntryBaseSchema.extend({
-    kind: z.literal('operator-decision'),
-    payload: OperatorDecisionPayloadSchema,
-});
-export const ValidatorResultRecordSchema = RecordEntryBaseSchema.extend({
-    kind: z.literal('validator-result'),
-    metrics: z.record(z.string(), z.unknown()).optional(),
-    payload: z
-        .object({
-        id: UuidV7Schema.optional(),
-    })
-        .optional(),
-    resultPath: z.string().optional(),
-    validator: z.enum(['parity', 'equiv', 'characterize', 'verify', 'doctor']),
-    verdict: z.enum(['green', 'yellow', 'red']),
-});
-export const RuntimeEventRecordSchema = RecordEntryBaseSchema.extend({
-    kind: z.literal('runtime-event'),
-    level: z.enum(['info', 'warn', 'error']),
-    message: z.string().min(1),
-    source: z.string().min(1),
-    stripDecisionId: z.string().optional(),
-});
-export const NoteRecordSchema = RecordEntryBaseSchema.extend({
-    body: z.string(),
-    kind: z.literal('note'),
-    subkind: NoteSubkindSchema,
-});
-export const CorrectionRecordSchema = RecordEntryBaseSchema.extend({
-    kind: z.literal('correction'),
-    payload: CorrectionPayloadSchema.optional(),
-    rationale: z.string().min(1),
-}).superRefine((value, ctx) => {
-    if (!value.links?.correctsLedgerId) {
-        ctx.addIssue({
-            code: 'custom',
-            message: 'correction records require links.correctsLedgerId',
-            path: ['links', 'correctsLedgerId'],
-        });
-    }
-});
-export const StripDecisionRevertedRecordSchema = RecordEntryBaseSchema.extend({
-    kind: z.literal('strip-decision-reverted'),
-    payload: StripDecisionRevertedPayloadSchema,
-});
-export const DescopeBriefRecordSchema = RecordEntryBaseSchema.extend({
-    kind: z.literal('descope-brief'),
-    payload: DescopeBriefPayloadSchema,
-});
-export const MergeReturnRecordSchema = RecordEntryBaseSchema.extend({
-    kind: z.literal('merge-return'),
-    payload: MergeReturnPayloadSchema,
-});
-export const MergeReturnRejectedRecordSchema = RecordEntryBaseSchema.extend({
-    kind: z.literal('merge-return-rejected'),
-    payload: MergeReturnRejectedPayloadSchema,
-});
-export const RevertRecordSchema = RecordEntryBaseSchema.extend({
-    kind: z.literal('revert'),
-    payload: RevertPayloadSchema,
-});
-export const RollbackRecordSchema = RecordEntryBaseSchema.extend({
-    kind: z.literal('rollback'),
-    payload: RollbackPayloadSchema,
-});
-export const ReworkTestRetiredRecordSchema = RecordEntryBaseSchema.extend({
-    kind: z.literal('rework.test_retired'),
-    payload: ReworkTestRetiredPayloadSchema,
-});
-export const LedgerRecordSchema = z.discriminatedUnion('kind', [
-    ToolInvocationRecordSchema,
-    AgentPatchRecordSchema,
-    OperatorPatchRecordSchema,
-    StageTransitionRecordSchema,
-    OperatorDecisionRecordSchema,
-    ValidatorResultRecordSchema,
-    RuntimeEventRecordSchema,
-    NoteRecordSchema,
-    CorrectionRecordSchema,
-    StripDecisionRevertedRecordSchema,
-    DescopeBriefRecordSchema,
-    MergeReturnRecordSchema,
-    MergeReturnRejectedRecordSchema,
-    RevertRecordSchema,
-    RollbackRecordSchema,
-    ReworkTestRetiredRecordSchema,
-]);
-const normalizePatchEntry = (entry) => ({
-    ...entry,
-    links: {
-        ...entry.links,
-        affectedFiles: mergeAffectedFiles(entry.links.affectedFiles, entry.payload.touchedPaths),
-    },
-});
-const normalizeLegacyAgentPatchEntry = (entry) => normalizePatchEntry({
-    ...entry,
-    _legacy: true,
-    payload: {
-        diffSha256: entry.diff.blobSha256,
-        fileSha256After: {},
-        fileSha256Before: {},
-        hunks: [],
-        touchedPaths: entry.links.affectedFiles ?? [],
-    },
-});
-const normalizeLegacyOperatorDecisionEntry = (entry) => ({
-    ...entry,
-    _legacy: true,
-    payload: {
-        action: mapLegacyDecisionTypeToAction(entry.decisionType),
-        checkId: typeof entry.links.stripDecisionId === 'string' ? entry.links.stripDecisionId : undefined,
-        rationale: typeof entry.body.rationale === 'string' && entry.body.rationale.trim().length > 0
-            ? entry.body.rationale
-            : entry.summary,
-    },
-});
-const normalizeLegacyValidatorResultEntry = (entry) => ({
-    ...entry,
-    _legacy: true,
-    payload: {
-        id: createDeterministicUuidV7({
-            seed: `${entry.id}:${entry.summary}:${entry.validator}:${entry.verdict}`,
-            timestamp: entry.ts,
-        }),
-    },
-});
-const normalizeCurrentEntry = (entry) => {
-    switch (entry.kind) {
-        case 'agent-patch':
-        case 'operator-patch':
-            return normalizePatchEntry(entry);
-        default:
-            return entry;
-    }
-};
-export const parseLedgerEntry = (input) => {
-    const current = LedgerEntrySchema.safeParse(input);
-    if (current.success) {
-        return normalizeCurrentEntry(current.data);
-    }
-    const legacyAgentPatch = LegacyAgentPatchEntrySchema.safeParse(input);
-    if (legacyAgentPatch.success) {
-        return normalizeLegacyAgentPatchEntry(legacyAgentPatch.data);
-    }
-    const legacyOperatorDecision = LegacyOperatorDecisionEntrySchema.safeParse(input);
-    if (legacyOperatorDecision.success) {
-        return normalizeLegacyOperatorDecisionEntry(legacyOperatorDecision.data);
-    }
-    const legacyValidatorResult = LegacyValidatorResultEntrySchema.safeParse(input);
-    if (legacyValidatorResult.success) {
-        return normalizeLegacyValidatorResultEntry(legacyValidatorResult.data);
-    }
-    return LedgerEntrySchema.parse(input);
-};
-export const parseLedgerRecord = (input) => LedgerRecordSchema.parse(input);
+import * as v from 'valibot';
+import { migrateLedgerEntryInput, migrateLedgerRecordInput } from "./entry-migrations.js";
+import { LedgerEntrySchema } from "./entry-read.js";
+import { LedgerRecordSchema } from "./entry-write.js";
+export * from "./entry-core.js";
+export * from "./entry-migrations.js";
+export * from "./entry-read.js";
+export * from "./entry-write.js";
+export const parseLedgerEntry = (input) => v.parse(LedgerEntrySchema, migrateLedgerEntryInput(input));
+export const parseLedgerRecord = (input) => v.parse(LedgerRecordSchema, migrateLedgerRecordInput(input));