ushman-ledger 0.3.0 → 1.2.0

package/dist/schema/entry-core.d.ts

@@ -0,0 +1,110 @@
+import * as v from 'valibot';
+export declare const LedgerSchemaVersion: "ushman-ledger-entry/v1";
+export declare const LEDGER_PHASES: readonly ["capture", "intake", "seed", "vendor-extract", "cleanup", "parity", "characterize", "equiv", "analyze", "recover", "ship", "migration"];
+export declare const LEDGER_KINDS: readonly ["tool-invocation", "agent-patch", "operator-patch", "operator-decision", "validator-result", "runtime-event", "note", "correction", "strip-decision-reverted", "change-log"];
+export declare const OPERATOR_DECISION_ACTIONS: readonly ["bypass-doctor", "skip-check", "override-strip-decision", "override-ship-state", "manual-parity-assertion", "ledger-hand-edit", "escalation"];
+export declare const NonEmptyTrimmedStringSchema: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>]>;
+export declare const WorkspaceRelativePathSchema: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.CheckAction<string, "Expected a normalized workspace-relative path.">]>;
+export declare const LedgerPhaseSchema: v.PicklistSchema<readonly ["capture", "intake", "seed", "vendor-extract", "cleanup", "parity", "characterize", "equiv", "analyze", "recover", "ship", "migration"], undefined>;
+export declare const LedgerKindSchema: v.PicklistSchema<readonly ["tool-invocation", "agent-patch", "operator-patch", "operator-decision", "validator-result", "runtime-event", "note", "correction", "strip-decision-reverted", "change-log"], undefined>;
+export declare const OperatorDecisionActionSchema: v.PicklistSchema<readonly ["bypass-doctor", "skip-check", "override-strip-decision", "override-ship-state", "manual-parity-assertion", "ledger-hand-edit", "escalation"], undefined>;
+export declare const ChangeLogSubkindSchema: v.PicklistSchema<readonly ["pre-change-checkpoint", "semantic-cleanup", "vendor-extract", "decomposition", "rollback", "hotfix", "smoke"], undefined>;
+export declare const ChangeLogSmokeResultSchema: v.PicklistSchema<readonly ["pass", "fail", "partial", "not-run"], undefined>;
+export declare const ChangeLogParityStatusSchema: v.PicklistSchema<readonly ["green", "yellow", "red", "not-run"], undefined>;
+export declare const EmitterSchema: v.ObjectSchema<{
+    readonly tool: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>]>;
+    readonly user: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>]>, undefined>;
+    readonly version: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>]>;
+}, undefined>;
+export declare const LedgerLinksSchema: v.ObjectWithRestSchema<{
+    readonly affectedFiles: v.OptionalSchema<v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.CheckAction<string, "Expected a normalized workspace-relative path.">]>, undefined>, undefined>;
+    readonly blobs: v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>;
+    readonly briefId: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    readonly correctsLedgerId: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    readonly gitRef: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    readonly idempotencyKey: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    readonly stripDecisionId: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    readonly supersedesLedgerId: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    readonly validatorVerdictId: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+}, v.UnknownSchema, undefined>;
+export declare const ledgerEntryBaseEntries: {
+    details: v.OptionalSchema<v.RecordSchema<v.StringSchema<undefined>, v.UnknownSchema, undefined>, undefined>;
+    emitter: v.ObjectSchema<{
+        readonly tool: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>]>;
+        readonly user: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>]>, undefined>;
+        readonly version: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>]>;
+    }, undefined>;
+    id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>]>;
+    links: v.OptionalSchema<v.ObjectWithRestSchema<{
+        readonly affectedFiles: v.OptionalSchema<v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.CheckAction<string, "Expected a normalized workspace-relative path.">]>, undefined>, undefined>;
+        readonly blobs: v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>;
+        readonly briefId: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+        readonly correctsLedgerId: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+        readonly gitRef: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+        readonly idempotencyKey: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+        readonly stripDecisionId: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+        readonly supersedesLedgerId: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+        readonly validatorVerdictId: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    }, v.UnknownSchema, undefined>, {}>;
+    phase: v.PicklistSchema<readonly ["capture", "intake", "seed", "vendor-extract", "cleanup", "parity", "characterize", "equiv", "analyze", "recover", "ship", "migration"], undefined>;
+    prevEntryId: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>]>, undefined>;
+    schemaVersion: v.LiteralSchema<"ushman-ledger-entry/v1", undefined>;
+    summary: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>]>;
+    ts: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, undefined>]>;
+};
+export declare const recordEntryBaseEntries: {
+    details: v.OptionalSchema<v.RecordSchema<v.StringSchema<undefined>, v.UnknownSchema, undefined>, undefined>;
+    emitter: v.ObjectSchema<{
+        readonly tool: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>]>;
+        readonly user: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>]>, undefined>;
+        readonly version: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>]>;
+    }, undefined>;
+    idempotencyKey: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>]>, undefined>;
+    links: v.OptionalSchema<v.ObjectWithRestSchema<{
+        readonly affectedFiles: v.OptionalSchema<v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.CheckAction<string, "Expected a normalized workspace-relative path.">]>, undefined>, undefined>;
+        readonly blobs: v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>;
+        readonly briefId: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+        readonly correctsLedgerId: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+        readonly gitRef: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+        readonly idempotencyKey: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+        readonly stripDecisionId: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+        readonly supersedesLedgerId: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+        readonly validatorVerdictId: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    }, v.UnknownSchema, undefined>, undefined>;
+    phase: v.PicklistSchema<readonly ["capture", "intake", "seed", "vendor-extract", "cleanup", "parity", "characterize", "equiv", "analyze", "recover", "ship", "migration"], undefined>;
+    summary: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>]>;
+};
+export declare const AgentPatchDiffSchema: v.ObjectSchema<{
+    readonly addedLines: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    readonly blobSha256: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "Expected a lowercase SHA-256 hex digest.">]>;
+    readonly bytes: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    readonly removedLines: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+}, undefined>;
+export declare const OperatorDecisionPayloadSchema: v.ObjectSchema<{
+    readonly action: v.PicklistSchema<readonly ["bypass-doctor", "skip-check", "override-strip-decision", "override-ship-state", "manual-parity-assertion", "ledger-hand-edit", "escalation"], undefined>;
+    readonly checkId: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>]>, undefined>;
+    readonly rationale: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>]>;
+}, undefined>;
+export declare const StripDecisionRevertedPayloadSchema: v.ObjectSchema<{
+    readonly invalidatedStages: v.OptionalSchema<v.ArraySchema<v.PicklistSchema<readonly ["intake", "seed", "vendor-extract", "cleanup", "parity", "characterize"], undefined>, undefined>, undefined>;
+    readonly rationale: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>]>;
+    readonly stripDecisionId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>]>;
+}, undefined>;
+export declare const ChangeLogFileChangeSchema: v.ObjectSchema<{
+    readonly added: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
+    readonly path: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.CheckAction<string, "Expected a normalized workspace-relative path.">]>;
+    readonly removed: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
+}, undefined>;
+export type AgentPatchDiff = v.InferOutput<typeof AgentPatchDiffSchema>;
+export type ChangeLogFileChange = v.InferOutput<typeof ChangeLogFileChangeSchema>;
+export type ChangeLogParityStatus = v.InferOutput<typeof ChangeLogParityStatusSchema>;
+export type ChangeLogSmokeResult = v.InferOutput<typeof ChangeLogSmokeResultSchema>;
+export type ChangeLogSubkind = v.InferOutput<typeof ChangeLogSubkindSchema>;
+export type LedgerKind = v.InferOutput<typeof LedgerKindSchema>;
+export type LedgerLinks = v.InferOutput<typeof LedgerLinksSchema>;
+export type LedgerPhase = v.InferOutput<typeof LedgerPhaseSchema>;
+export type OperatorDecisionAction = v.InferOutput<typeof OperatorDecisionActionSchema>;
+export type OperatorDecisionPayload = v.InferOutput<typeof OperatorDecisionPayloadSchema>;
+export type StripDecisionRevertedPayload = v.InferOutput<typeof StripDecisionRevertedPayloadSchema>;
+export type WorkspaceRelativePath = v.InferOutput<typeof WorkspaceRelativePathSchema>;
+//# sourceMappingURL=entry-core.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"entry-core.d.ts","sourceRoot":"","sources":["../../src/schema/entry-core.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAC;AAE7B,eAAO,MAAM,mBAAmB,EAAG,wBAAiC,CAAC;AAErE,eAAO,MAAM,aAAa,mJAahB,CAAC;AAEX,eAAO,MAAM,YAAY,wLAWf,CAAC;AAEX,eAAO,MAAM,yBAAyB,yJAQ5B,CAAC;AAiDX,eAAO,MAAM,2BAA2B,+GAA+C,CAAC;AAExF,eAAO,MAAM,2BAA2B,0KAIvC,CAAC;AAIF,eAAO,MAAM,iBAAiB,gLAA4B,CAAC;AAC3D,eAAO,MAAM,gBAAgB,qNAA2B,CAAC;AACzD,eAAO,MAAM,4BAA4B,sLAAwC,CAAC;AAElF,eAAO,MAAM,sBAAsB,uJAAkC,CAAC;AACtE,eAAO,MAAM,0BAA0B,8EAAuC,CAAC;AAC/E,eAAO,MAAM,2BAA2B,6EAAyC,CAAC;AAElF,eAAO,MAAM,aAAa;;;;aAIxB,CAAC;AAEH,eAAO,MAAM,iBAAiB;;;;;;;;;;8BAa7B,CAAC;AAEF,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;CAUlC,CAAC;AAEF,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;CAOlC,CAAC;AAEF,eAAO,MAAM,oBAAoB;;;;;aAK/B,CAAC;AAEH,eAAO,MAAM,6BAA6B;;;;aAIxC,CAAC;AAEH,eAAO,MAAM,kCAAkC;;;;aAI7C,CAAC;AAEH,eAAO,MAAM,yBAAyB;;;;aAIpC,CAAC;AAEH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,oBAAoB,CAAC,CAAC;AACxE,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAClF,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,2BAA2B,CAAC,CAAC;AACtF,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,0BAA0B,CAAC,CAAC;AACpF,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAC5E,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAChE,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAClE,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAClE,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,4BAA4B,CAAC,CAAC;AACxF,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,6BAA6B,CAAC,CAAC;AAC1F,MAAM,MAAM,4BAA4B,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,kCAAkC,CAAC,CAAC;AACpG,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,2BAA2B,CAAC,CAAC"}

package/dist/schema/entry-core.js

@@ -0,0 +1,143 @@
+import path from 'node:path';
+import * as v from 'valibot';
+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',
+    'operator-decision',
+    'validator-result',
+    'runtime-event',
+    'note',
+    'correction',
+    'strip-decision-reverted',
+    'change-log',
+];
+export const OPERATOR_DECISION_ACTIONS = [
+    'bypass-doctor',
+    'skip-check',
+    'override-strip-decision',
+    'override-ship-state',
+    'manual-parity-assertion',
+    'ledger-hand-edit',
+    'escalation',
+];
+const STRIP_DECISION_INVALIDATED_STAGES = [
+    'intake',
+    'seed',
+    'vendor-extract',
+    'cleanup',
+    'parity',
+    'characterize',
+];
+const CHANGE_LOG_SUBKINDS = [
+    'pre-change-checkpoint',
+    'semantic-cleanup',
+    'vendor-extract',
+    'decomposition',
+    'rollback',
+    'hotfix',
+    'smoke',
+];
+const CHANGE_LOG_SMOKE_RESULTS = ['pass', 'fail', 'partial', 'not-run'];
+const CHANGE_LOG_PARITY_STATUSES = ['green', 'yellow', 'red', 'not-run'];
+const SHA256_HEX_PATTERN = /^[a-f0-9]{64}$/u;
+const WINDOWS_ABSOLUTE_PATH_PATTERN = /^[a-z]:[\\/]/iu;
+const normalizeWorkspaceRelativePath = (value) => value.replaceAll('\\', '/');
+const isNormalizedWorkspaceRelativePath = (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('..');
+};
+export const NonEmptyTrimmedStringSchema = v.pipe(v.string(), v.trim(), v.minLength(1));
+export const WorkspaceRelativePathSchema = v.pipe(v.string(), v.minLength(1), v.check(isNormalizedWorkspaceRelativePath, 'Expected a normalized workspace-relative path.'));
+const SHA256HexSchema = v.pipe(v.string(), v.regex(SHA256_HEX_PATTERN, 'Expected a lowercase SHA-256 hex digest.'));
+export const LedgerPhaseSchema = v.picklist(LEDGER_PHASES);
+export const LedgerKindSchema = v.picklist(LEDGER_KINDS);
+export const OperatorDecisionActionSchema = v.picklist(OPERATOR_DECISION_ACTIONS);
+const StripDecisionInvalidatedStageSchema = v.picklist(STRIP_DECISION_INVALIDATED_STAGES);
+export const ChangeLogSubkindSchema = v.picklist(CHANGE_LOG_SUBKINDS);
+export const ChangeLogSmokeResultSchema = v.picklist(CHANGE_LOG_SMOKE_RESULTS);
+export const ChangeLogParityStatusSchema = v.picklist(CHANGE_LOG_PARITY_STATUSES);
+export const EmitterSchema = v.object({
+    tool: NonEmptyTrimmedStringSchema,
+    user: v.optional(NonEmptyTrimmedStringSchema),
+    version: NonEmptyTrimmedStringSchema,
+});
+export const LedgerLinksSchema = v.objectWithRest({
+    affectedFiles: v.optional(v.array(WorkspaceRelativePathSchema)),
+    blobs: v.optional(v.array(v.string())),
+    briefId: v.optional(v.string()),
+    correctsLedgerId: v.optional(v.string()),
+    gitRef: v.optional(v.string()),
+    idempotencyKey: v.optional(v.string()),
+    stripDecisionId: v.optional(v.string()),
+    supersedesLedgerId: v.optional(v.string()),
+    validatorVerdictId: v.optional(v.string()),
+}, v.unknown());
+export const ledgerEntryBaseEntries = {
+    details: v.optional(v.record(v.string(), v.unknown())),
+    emitter: EmitterSchema,
+    id: NonEmptyTrimmedStringSchema,
+    links: v.optional(LedgerLinksSchema, {}),
+    phase: LedgerPhaseSchema,
+    prevEntryId: v.nullable(NonEmptyTrimmedStringSchema),
+    schemaVersion: v.literal(LedgerSchemaVersion),
+    summary: NonEmptyTrimmedStringSchema,
+    ts: v.pipe(v.string(), v.isoTimestamp()),
+};
+export const recordEntryBaseEntries = {
+    details: v.optional(v.record(v.string(), v.unknown())),
+    emitter: EmitterSchema,
+    idempotencyKey: v.optional(NonEmptyTrimmedStringSchema),
+    links: v.optional(LedgerLinksSchema),
+    phase: LedgerPhaseSchema,
+    summary: NonEmptyTrimmedStringSchema,
+};
+export const AgentPatchDiffSchema = v.object({
+    addedLines: v.pipe(v.number(), v.integer(), v.minValue(0)),
+    blobSha256: SHA256HexSchema,
+    bytes: v.pipe(v.number(), v.integer(), v.minValue(0)),
+    removedLines: v.pipe(v.number(), v.integer(), v.minValue(0)),
+});
+export const OperatorDecisionPayloadSchema = v.object({
+    action: OperatorDecisionActionSchema,
+    checkId: v.optional(NonEmptyTrimmedStringSchema),
+    rationale: NonEmptyTrimmedStringSchema,
+});
+export const StripDecisionRevertedPayloadSchema = v.object({
+    invalidatedStages: v.optional(v.array(StripDecisionInvalidatedStageSchema)),
+    rationale: NonEmptyTrimmedStringSchema,
+    stripDecisionId: NonEmptyTrimmedStringSchema,
+});
+export const ChangeLogFileChangeSchema = v.object({
+    added: v.optional(v.pipe(v.number(), v.integer(), v.minValue(0))),
+    path: WorkspaceRelativePathSchema,
+    removed: v.optional(v.pipe(v.number(), v.integer(), v.minValue(0))),
+});

package/dist/schema/entry-migrations.d.ts

@@ -0,0 +1,3 @@
+export declare const migrateLedgerEntryInput: (input: unknown) => unknown;
+export declare const migrateLedgerRecordInput: (input: unknown) => unknown;
+//# sourceMappingURL=entry-migrations.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"entry-migrations.d.ts","sourceRoot":"","sources":["../../src/schema/entry-migrations.ts"],"names":[],"mappings":"AAoDA,eAAO,MAAM,uBAAuB,GAAI,OAAO,OAAO,YAA8B,CAAC;AAErF,eAAO,MAAM,wBAAwB,GAAI,OAAO,OAAO,YAA8B,CAAC"}

package/dist/schema/entry-migrations.js

@@ -0,0 +1,48 @@
+const isRecord = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
+const migrateOperatorDecision = (input) => {
+    if (input.kind !== 'operator-decision' || isRecord(input.payload)) {
+        return input;
+    }
+    const action = input.action;
+    const rationale = input.rationale;
+    if (typeof action !== 'string' || typeof rationale !== 'string') {
+        return input;
+    }
+    return {
+        ...input,
+        payload: {
+            action,
+            checkId: typeof input.checkId === 'string' ? input.checkId : undefined,
+            rationale,
+        },
+    };
+};
+const migrateValidatorResult = (input) => {
+    if (input.kind !== 'validator-result' || typeof input.verdict === 'string') {
+        return input;
+    }
+    if (typeof input.status !== 'string') {
+        return input;
+    }
+    return {
+        ...input,
+        verdict: input.status,
+    };
+};
+const migrateChangeLog = (input) => {
+    if (input.kind !== 'change-log' || Array.isArray(input.filesChanged)) {
+        return input;
+    }
+    return {
+        ...input,
+        filesChanged: [],
+    };
+};
+const migrateLedgerInput = (input) => {
+    if (!isRecord(input)) {
+        return input;
+    }
+    return migrateChangeLog(migrateValidatorResult(migrateOperatorDecision({ ...input })));
+};
+export const migrateLedgerEntryInput = (input) => migrateLedgerInput(input);
+export const migrateLedgerRecordInput = (input) => migrateLedgerInput(input);