kibi-cli 0.19.0 → 2.0.0

package/dist/public/proof-receipt.d.ts

@@ -0,0 +1,279 @@
+import { type ProofFingerprintComponents } from "./proof-fingerprint.js";
+import { PROOF_RECEIPT_VERSION, PROOF_RESULT_OUTCOMES, PROOF_RUN_OUTCOMES, type ProofContract } from "./proof-protocol.js";
+export declare const PROOF_RECEIPT_MAX_AGE_SECONDS: number;
+export declare const PROOF_RECEIPT_OUTCOMES: readonly ["passed", "failed", "errored", "cancelled", "skipped", "timed_out", "interrupted"];
+export declare const PROOF_RECEIPT_SCHEMA: {
+    readonly type: "object";
+    readonly description: "Kibi-derived kibi.proof-receipt.v1. Receipts are never caller-authored; kb_ingest_proof derives them from kibi.proof-run.v1 artifacts.";
+    readonly required: readonly ["version", "receipt_id", "test_id", "scope", "outcome", "code_snapshot", "environment_hash", "started_at", "finished_at", "artifact_digest", "contract_hash", "fingerprint", "fingerprint_components", "integration_id", "producer", "command_argv", "run_outcome", "proof_results"];
+    readonly properties: {
+        readonly version: {
+            readonly type: "string";
+            readonly const: "kibi.proof-receipt.v1";
+        };
+        readonly receipt_id: {
+            readonly type: "string";
+            readonly pattern: "^PR-[A-Za-z0-9][A-Za-z0-9._:-]{7,127}$";
+        };
+        readonly test_id: {
+            readonly type: "string";
+            readonly minLength: 1;
+        };
+        readonly scope: {
+            readonly type: "string";
+            readonly enum: readonly ["unit", "integration", "end_to_end"];
+        };
+        readonly outcome: {
+            readonly type: "string";
+            readonly enum: readonly ["passed", "failed", "errored", "cancelled", "skipped", "timed_out", "interrupted"];
+        };
+        readonly code_snapshot: {
+            readonly type: "string";
+            readonly pattern: "^[a-f0-9]{64}$";
+        };
+        readonly environment_hash: {
+            readonly type: "string";
+            readonly pattern: "^[a-f0-9]{64}$";
+        };
+        readonly started_at: {
+            readonly type: "string";
+            readonly minLength: 1;
+        };
+        readonly finished_at: {
+            readonly type: "string";
+            readonly minLength: 1;
+        };
+        readonly artifact_digest: {
+            readonly type: "string";
+            readonly pattern: "^[a-f0-9]{64}$";
+        };
+        readonly contract_hash: {
+            readonly type: "string";
+            readonly pattern: "^[a-f0-9]{64}$";
+        };
+        readonly binding_hash: {
+            readonly type: "string";
+            readonly pattern: "^[a-f0-9]{64}$";
+        };
+        readonly fingerprint: {
+            readonly type: "string";
+            readonly pattern: "^[a-f0-9]{64}$";
+        };
+        readonly fingerprint_components: {
+            readonly type: "object";
+            readonly required: readonly ["contract", "integration", "command", "bindings", "producer"];
+            readonly additionalProperties: false;
+            readonly properties: {
+                readonly contract: {
+                    readonly type: "string";
+                    readonly pattern: "^[a-f0-9]{64}$";
+                };
+                readonly integration: {
+                    readonly type: "string";
+                    readonly pattern: "^[a-f0-9]{64}$";
+                };
+                readonly command: {
+                    readonly type: "string";
+                    readonly pattern: "^[a-f0-9]{64}$";
+                };
+                readonly bindings: {
+                    readonly type: "string";
+                    readonly pattern: "^[a-f0-9]{64}$";
+                };
+                readonly producer: {
+                    readonly type: "string";
+                    readonly pattern: "^[a-f0-9]{64}$";
+                };
+            };
+        };
+        readonly integration_id: {
+            readonly type: "string";
+            readonly minLength: 1;
+        };
+        readonly producer: {
+            readonly type: "object";
+            readonly required: readonly ["name"];
+            readonly properties: {
+                readonly name: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                };
+                readonly version: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                };
+            };
+            readonly additionalProperties: false;
+        };
+        readonly command_argv: {
+            readonly type: "array";
+            readonly minItems: 1;
+            readonly items: {
+                readonly type: "string";
+                readonly minLength: 1;
+            };
+        };
+        readonly run_outcome: {
+            readonly type: "string";
+            readonly enum: readonly ["passed", "failed", "errored", "cancelled", "timed_out", "interrupted", "no_results"];
+        };
+        readonly proof_results: {
+            readonly type: "array";
+            readonly minItems: 0;
+            readonly maxItems: 1000;
+            readonly items: {
+                readonly type: "object";
+                readonly required: readonly ["symbol_id", "target", "outcome", "binding", "attempts"];
+                readonly properties: {
+                    readonly symbol_id: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                    };
+                    readonly target: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                    };
+                    readonly outcome: {
+                        readonly type: "string";
+                        readonly enum: readonly ["passed", "failed", "timed_out", "skipped", "interrupted", "errored"];
+                    };
+                    readonly binding: {
+                        readonly type: "string";
+                        readonly enum: readonly ["native_case", "aggregate_run"];
+                    };
+                    readonly native_id: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                    };
+                    readonly attempts: {
+                        readonly oneOf: readonly [{
+                            readonly type: "object";
+                            readonly required: readonly ["status", "entries"];
+                            readonly properties: {
+                                readonly status: {
+                                    readonly type: "string";
+                                    readonly const: "complete";
+                                };
+                                readonly entries: {
+                                    readonly type: "array";
+                                    readonly minItems: 1;
+                                    readonly items: {
+                                        readonly type: "object";
+                                        readonly required: readonly ["outcome"];
+                                        readonly properties: {
+                                            readonly outcome: {
+                                                readonly type: "string";
+                                                readonly enum: readonly ["passed", "failed", "timed_out", "skipped", "interrupted", "errored"];
+                                            };
+                                            readonly duration_ms: {
+                                                readonly type: "number";
+                                                readonly minimum: 0;
+                                            };
+                                        };
+                                        readonly additionalProperties: false;
+                                    };
+                                };
+                            };
+                            readonly additionalProperties: false;
+                        }, {
+                            readonly type: "object";
+                            readonly required: readonly ["status"];
+                            readonly properties: {
+                                readonly status: {
+                                    readonly type: "string";
+                                    readonly const: "unavailable";
+                                };
+                            };
+                            readonly additionalProperties: false;
+                        }];
+                    };
+                };
+                readonly additionalProperties: false;
+            };
+        };
+        readonly gaps: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "object";
+                readonly required: readonly ["symbol_id", "target", "reason"];
+                readonly properties: {
+                    readonly symbol_id: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                    };
+                    readonly target: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                    };
+                    readonly reason: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                    };
+                };
+                readonly additionalProperties: false;
+            };
+        };
+    };
+    readonly additionalProperties: false;
+};
+export type ProofReceipt = Readonly<{
+    version: typeof PROOF_RECEIPT_VERSION;
+    receipt_id: string;
+    test_id: string;
+    scope: "unit" | "integration" | "end_to_end";
+    outcome: (typeof PROOF_RECEIPT_OUTCOMES)[number];
+    code_snapshot: string;
+    environment_hash: string;
+    started_at: string;
+    finished_at: string;
+    artifact_digest: string;
+    contract_hash: string;
+    fingerprint: string;
+    fingerprint_components: ProofFingerprintComponents;
+    integration_id: string;
+    producer: {
+        readonly name: string;
+        readonly version?: string;
+    };
+    command_argv: readonly string[];
+    run_outcome: (typeof PROOF_RUN_OUTCOMES)[number];
+    proof_results: readonly {
+        readonly symbol_id: string;
+        readonly target: string;
+        readonly outcome: (typeof PROOF_RESULT_OUTCOMES)[number];
+        readonly binding: "native_case" | "aggregate_run";
+        readonly native_id?: string;
+        readonly attempts: {
+            readonly status: "complete";
+            readonly entries: readonly {
+                readonly outcome: string;
+                readonly duration_ms?: number;
+            }[];
+        } | {
+            readonly status: "unavailable";
+        };
+    }[];
+    gaps?: readonly {
+        readonly symbol_id: string;
+        readonly target: string;
+        readonly reason: string;
+    }[];
+}>;
+export declare function finishedAtPrecedesStartedAt(startedAt: number | null, finishedAt: number | null): boolean;
+/** Structural validation of one kibi.proof-receipt.v1 entry. */
+export declare function validProofReceiptShape(testId: string, receipt: unknown): boolean;
+/**
+ * Full-history validation for proof_receipts: unique ids, per-test binding,
+ * supported scope, ordered timestamps, and structurally valid v1 entries.
+ */
+export declare function proofReceiptHistoryErrors(testId: string, verificationScope: unknown, receipts: readonly Readonly<Record<string, unknown>>[]): readonly string[];
+/** The current receipt must match the live scope, contract hash, and fingerprint. */
+export declare function proofReceiptCurrentBindingErrors(testId: string, verificationScope: unknown, receipt: Readonly<Record<string, unknown>>, contract?: ProofContract, fingerprint?: string): readonly string[];
+/**
+ * Hard schema cap on stored receipts per test. Ingest appends past this cap by
+ * rotating: drop exactly the oldest receipts so the newest evidence stays
+ * bound to the test without ever exceeding the cap.
+ */
+export declare const MAX_PROOF_RECEIPTS = 50;
+export declare function appendOnlyProofReceiptHistoryErrors(previous: readonly Readonly<Record<string, unknown>>[], next: readonly Readonly<Record<string, unknown>>[] | undefined): readonly string[];
+//# sourceMappingURL=proof-receipt.d.ts.map

package/dist/public/proof-receipt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"proof-receipt.d.ts","sourceRoot":"","sources":["../../src/public/proof-receipt.ts"],"names":[],"mappings":"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"}

package/dist/public/proof-receipt.js

@@ -0,0 +1,377 @@
+import { canonicalJson, proofContractHash, } from "./proof-fingerprint.js";
+import { PROOF_RECEIPT_VERSION, PROOF_RESULT_OUTCOMES, PROOF_RUN_OUTCOMES, } from "./proof-protocol.js";
+export const PROOF_RECEIPT_MAX_AGE_SECONDS = 7 * 24 * 60 * 60;
+export const PROOF_RECEIPT_OUTCOMES = [
+    "passed",
+    "failed",
+    "errored",
+    "cancelled",
+    "skipped",
+    "timed_out",
+    "interrupted",
+];
+export const PROOF_RECEIPT_SCHEMA = {
+    type: "object",
+    description: "Kibi-derived kibi.proof-receipt.v1. Receipts are never caller-authored; kb_ingest_proof derives them from kibi.proof-run.v1 artifacts.",
+    required: [
+        "version",
+        "receipt_id",
+        "test_id",
+        "scope",
+        "outcome",
+        "code_snapshot",
+        "environment_hash",
+        "started_at",
+        "finished_at",
+        "artifact_digest",
+        "contract_hash",
+        "fingerprint",
+        "fingerprint_components",
+        "integration_id",
+        "producer",
+        "command_argv",
+        "run_outcome",
+        "proof_results",
+    ],
+    properties: {
+        version: { type: "string", const: PROOF_RECEIPT_VERSION },
+        receipt_id: {
+            type: "string",
+            pattern: "^PR-[A-Za-z0-9][A-Za-z0-9._:-]{7,127}$",
+        },
+        test_id: { type: "string", minLength: 1 },
+        scope: { type: "string", enum: ["unit", "integration", "end_to_end"] },
+        outcome: { type: "string", enum: [...PROOF_RECEIPT_OUTCOMES] },
+        code_snapshot: { type: "string", pattern: "^[a-f0-9]{64}$" },
+        environment_hash: { type: "string", pattern: "^[a-f0-9]{64}$" },
+        started_at: { type: "string", minLength: 1 },
+        finished_at: { type: "string", minLength: 1 },
+        artifact_digest: { type: "string", pattern: "^[a-f0-9]{64}$" },
+        contract_hash: { type: "string", pattern: "^[a-f0-9]{64}$" },
+        binding_hash: { type: "string", pattern: "^[a-f0-9]{64}$" },
+        fingerprint: { type: "string", pattern: "^[a-f0-9]{64}$" },
+        fingerprint_components: {
+            type: "object",
+            required: ["contract", "integration", "command", "bindings", "producer"],
+            additionalProperties: false,
+            properties: {
+                contract: { type: "string", pattern: "^[a-f0-9]{64}$" },
+                integration: { type: "string", pattern: "^[a-f0-9]{64}$" },
+                command: { type: "string", pattern: "^[a-f0-9]{64}$" },
+                bindings: { type: "string", pattern: "^[a-f0-9]{64}$" },
+                producer: { type: "string", pattern: "^[a-f0-9]{64}$" },
+            },
+        },
+        integration_id: { type: "string", minLength: 1 },
+        producer: {
+            type: "object",
+            required: ["name"],
+            properties: {
+                name: { type: "string", minLength: 1 },
+                version: { type: "string", minLength: 1 },
+            },
+            additionalProperties: false,
+        },
+        command_argv: {
+            type: "array",
+            minItems: 1,
+            items: { type: "string", minLength: 1 },
+        },
+        run_outcome: { type: "string", enum: [...PROOF_RUN_OUTCOMES] },
+        proof_results: {
+            type: "array",
+            minItems: 0,
+            maxItems: 1000,
+            items: {
+                type: "object",
+                required: ["symbol_id", "target", "outcome", "binding", "attempts"],
+                properties: {
+                    symbol_id: { type: "string", minLength: 1 },
+                    target: { type: "string", minLength: 1 },
+                    outcome: { type: "string", enum: [...PROOF_RESULT_OUTCOMES] },
+                    binding: { type: "string", enum: ["native_case", "aggregate_run"] },
+                    native_id: { type: "string", minLength: 1 },
+                    attempts: {
+                        oneOf: [
+                            {
+                                type: "object",
+                                required: ["status", "entries"],
+                                properties: {
+                                    status: { type: "string", const: "complete" },
+                                    entries: {
+                                        type: "array",
+                                        minItems: 1,
+                                        items: {
+                                            type: "object",
+                                            required: ["outcome"],
+                                            properties: {
+                                                outcome: {
+                                                    type: "string",
+                                                    enum: [...PROOF_RESULT_OUTCOMES],
+                                                },
+                                                duration_ms: { type: "number", minimum: 0 },
+                                            },
+                                            additionalProperties: false,
+                                        },
+                                    },
+                                },
+                                additionalProperties: false,
+                            },
+                            {
+                                type: "object",
+                                required: ["status"],
+                                properties: {
+                                    status: { type: "string", const: "unavailable" },
+                                },
+                                additionalProperties: false,
+                            },
+                        ],
+                    },
+                },
+                additionalProperties: false,
+            },
+        },
+        gaps: {
+            type: "array",
+            items: {
+                type: "object",
+                required: ["symbol_id", "target", "reason"],
+                properties: {
+                    symbol_id: { type: "string", minLength: 1 },
+                    target: { type: "string", minLength: 1 },
+                    reason: { type: "string", minLength: 1 },
+                },
+                additionalProperties: false,
+            },
+        },
+    },
+    additionalProperties: false,
+};
+export function finishedAtPrecedesStartedAt(startedAt, finishedAt) {
+    return startedAt !== null && finishedAt !== null && finishedAt < startedAt;
+}
+function timestamp(value) {
+    if (typeof value !== "string")
+        return null;
+    if (!/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})$/.test(value)) {
+        return null;
+    }
+    const parsed = Date.parse(value);
+    return Number.isFinite(parsed) ? parsed : null;
+}
+function nonEmptyString(value) {
+    return typeof value === "string" && value.trim().length > 0;
+}
+function hex64(value) {
+    return typeof value === "string" && /^[a-f0-9]{64}$/.test(value);
+}
+function isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function validAttempts(value) {
+    const row = isRecord(value) ? value : null;
+    if (!row)
+        return false;
+    if (row.status === "unavailable")
+        return row.entries === undefined;
+    if (row.status !== "complete")
+        return false;
+    if (!Array.isArray(row.entries) || row.entries.length === 0)
+        return false;
+    return row.entries.every((entry) => {
+        const attempt = isRecord(entry) ? entry : null;
+        return (attempt !== null &&
+            nonEmptyString(attempt.outcome) &&
+            PROOF_RESULT_OUTCOMES.includes(String(attempt.outcome)) &&
+            (attempt.duration_ms === undefined ||
+                (Number.isInteger(attempt.duration_ms) &&
+                    Number(attempt.duration_ms) >= 0)));
+    });
+}
+function validReceiptProofResult(value) {
+    const row = isRecord(value) ? value : null;
+    if (!row)
+        return false;
+    return (nonEmptyString(row.symbol_id) &&
+        nonEmptyString(row.target) &&
+        PROOF_RESULT_OUTCOMES.includes(String(row.outcome)) &&
+        ["native_case", "aggregate_run"].includes(String(row.binding)) &&
+        (row.native_id === undefined || nonEmptyString(row.native_id)) &&
+        validAttempts(row.attempts));
+}
+function validFingerprintComponents(value) {
+    const row = isRecord(value) ? value : null;
+    if (!row)
+        return false;
+    return (hex64(row.contract) &&
+        hex64(row.integration) &&
+        hex64(row.command) &&
+        hex64(row.bindings) &&
+        hex64(row.producer));
+}
+/** Structural validation of one kibi.proof-receipt.v1 entry. */
+export function validProofReceiptShape(testId, receipt) {
+    const row = isRecord(receipt) ? receipt : null;
+    if (!row)
+        return false;
+    if (row.version !== PROOF_RECEIPT_VERSION)
+        return false;
+    if (typeof row.receipt_id !== "string" ||
+        !/^PR-[A-Za-z0-9][A-Za-z0-9._:-]{7,127}$/.test(row.receipt_id))
+        return false;
+    if (row.test_id !== testId)
+        return false;
+    if (!["unit", "integration", "end_to_end"].includes(String(row.scope)))
+        return false;
+    if (!PROOF_RECEIPT_OUTCOMES.includes(String(row.outcome)))
+        return false;
+    if (!hex64(row.code_snapshot) || !hex64(row.environment_hash))
+        return false;
+    if (!hex64(row.artifact_digest))
+        return false;
+    if (!hex64(row.contract_hash) || !hex64(row.fingerprint))
+        return false;
+    if (row.binding_hash !== undefined &&
+        (typeof row.binding_hash !== "string" || !hex64(row.binding_hash))) {
+        return false;
+    }
+    if (!validFingerprintComponents(row.fingerprint_components))
+        return false;
+    if (!nonEmptyString(row.integration_id))
+        return false;
+    const producer = isRecord(row.producer) ? row.producer : null;
+    if (!producer || !nonEmptyString(producer.name))
+        return false;
+    if (producer.version !== undefined && !nonEmptyString(producer.version))
+        return false;
+    if (!Array.isArray(row.command_argv) ||
+        row.command_argv.length === 0 ||
+        !row.command_argv.every((argument) => nonEmptyString(argument)))
+        return false;
+    if (!PROOF_RUN_OUTCOMES.includes(String(row.run_outcome)))
+        return false;
+    if (!Array.isArray(row.proof_results) ||
+        !row.proof_results.every(validReceiptProofResult))
+        return false;
+    if (row.gaps !== undefined) {
+        if (!Array.isArray(row.gaps))
+            return false;
+        if (!row.gaps.every((gap) => isRecord(gap) &&
+            nonEmptyString(gap.symbol_id) &&
+            nonEmptyString(gap.target) &&
+            nonEmptyString(gap.reason)))
+            return false;
+    }
+    const startedAt = timestamp(row.started_at);
+    const finishedAt = timestamp(row.finished_at);
+    if (startedAt === null || finishedAt === null)
+        return false;
+    return !finishedAtPrecedesStartedAt(startedAt, finishedAt);
+}
+/**
+ * Full-history validation for proof_receipts: unique ids, per-test binding,
+ * supported scope, ordered timestamps, and structurally valid v1 entries.
+ */
+export function proofReceiptHistoryErrors(testId, verificationScope, receipts) {
+    const errors = [];
+    if (receipts.length > 0 && typeof verificationScope !== "string") {
+        errors.push("verification_scope is required when proof_receipts are present");
+    }
+    const receiptIds = new Set();
+    for (const [index, receipt] of receipts.entries()) {
+        const prefix = `proof_receipts[${index}]`;
+        const receiptId = receipt.receipt_id;
+        if (typeof receiptId === "string") {
+            if (receiptIds.has(receiptId)) {
+                errors.push(`${prefix}.receipt_id duplicates '${receiptId}'`);
+            }
+            receiptIds.add(receiptId);
+        }
+        if (receipt.test_id !== testId) {
+            errors.push(`${prefix}.test_id must equal '${testId}'`);
+        }
+        if (!validProofReceiptShape(testId, receipt)) {
+            errors.push(`${prefix} must be a structurally valid kibi.proof-receipt.v1 bound to '${testId}'`);
+            continue;
+        }
+        const finishedAt = timestamp(receipt.finished_at);
+        if (finishedAt !== null &&
+            index > 0 &&
+            timestamp(receipts[index - 1]?.finished_at) !== null &&
+            finishedAt <= timestamp(receipts[index - 1]?.finished_at)) {
+            errors.push(`${prefix}.finished_at must be strictly later than the previous receipt`);
+        }
+    }
+    return errors;
+}
+/** The current receipt must match the live scope, contract hash, and fingerprint. */
+export function proofReceiptCurrentBindingErrors(testId, verificationScope, receipt, contract, fingerprint) {
+    const errors = [];
+    if (receipt.test_id !== testId) {
+        errors.push(`proof receipt test_id must equal '${testId}'`);
+    }
+    if (typeof verificationScope !== "string") {
+        errors.push("verification_scope is required for current receipt evidence");
+    }
+    else if (receipt.scope !== verificationScope) {
+        errors.push(`proof receipt scope must equal the current verification_scope '${verificationScope}'`);
+    }
+    if (contract !== undefined) {
+        if (typeof receipt.contract_hash === "string") {
+            const expectedHash = proofContractHash(contract);
+            if (receipt.contract_hash !== expectedHash) {
+                errors.push("proof receipt contract_hash does not match the current proof_contract");
+            }
+        }
+        if (fingerprint !== undefined &&
+            typeof receipt.fingerprint === "string" &&
+            receipt.fingerprint !== fingerprint) {
+            errors.push("proof receipt fingerprint does not match the current effective execution fingerprint");
+        }
+    }
+    return errors;
+}
+/**
+ * Hard schema cap on stored receipts per test. Ingest appends past this cap by
+ * rotating: drop exactly the oldest receipts so the newest evidence stays
+ * bound to the test without ever exceeding the cap.
+ */
+export const MAX_PROOF_RECEIPTS = 50;
+function isCapRotation(previous, next) {
+    if (next.length !== MAX_PROOF_RECEIPTS)
+        return false;
+    if (previous.length < MAX_PROOF_RECEIPTS)
+        return false;
+    const preserved = MAX_PROOF_RECEIPTS - 1;
+    for (let index = 0; index < preserved; index++) {
+        if (canonicalJson(previous[previous.length - preserved + index]) !==
+            canonicalJson(next[index])) {
+            return false;
+        }
+    }
+    return true;
+}
+export function appendOnlyProofReceiptHistoryErrors(previous, next) {
+    if (previous.length === 0)
+        return [];
+    if (next === undefined) {
+        return [
+            "proof_receipts is append-only and cannot be removed from an existing test",
+        ];
+    }
+    if (isCapRotation(previous, next))
+        return [];
+    if (next.length < previous.length) {
+        return [
+            `proof_receipts is append-only: expected at least ${previous.length} historical receipt(s), received ${next.length}`,
+        ];
+    }
+    for (const [index, receipt] of previous.entries()) {
+        if (canonicalJson(next[index]) !== canonicalJson(receipt)) {
+            return [
+                `proof_receipts is append-only: historical receipt at index ${index} was changed, removed, or reordered`,
+            ];
+        }
+    }
+    return [];
+}

package/dist/public/schemas/entity.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"entity.d.ts","sourceRoot":"","sources":["../../../src/public/schemas/entity.ts"],"names":[],"mappings":"AAwTA,QAAA,MAAM,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CA6TzC,CAAC;AAEF,eAAe,YAAY,CAAC"}
+{"version":3,"file":"entity.d.ts","sourceRoot":"","sources":["../../../src/public/schemas/entity.ts"],"names":[],"mappings":"AA4TA,QAAA,MAAM,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CA8UzC,CAAC;AAEF,eAAe,YAAY,CAAC"}