niceeval 0.13.2 → 0.13.3

package/dist/analysis/bindings.d.ts

@@ -979,34 +979,97 @@ export declare const publishedAnalysisInputBindings: Readonly<{
         id: "niceeval.attempt-passed";
         family: FixedFamilyBinding<"attempt", {
             readonly entries: readonly {
-                readonly result: import("../assertions/record/model.js").SealedAssertionResult;
-                readonly coverage: import("../assertions/record/model.js").AssertionCoverage;
-                readonly limitations: readonly import("../assertions/record/model.js").AssertionLimitation[];
-                readonly subject: {
-                    readonly value: import("../assertions/record/model.js").BoundedJsonValue;
-                    readonly kind: "snapshot";
-                } | {
-                    readonly kind: "blob";
-                    readonly ref: RecordBlobRef;
-                    readonly sha256: import("../record/model/identifiers.js").Sha256Digest;
-                    readonly encoding: "utf-8" | "binary";
-                    readonly preview: string;
-                    readonly byteLength: number;
+                readonly evaluation: {
+                    readonly receipt?: {
+                        readonly complete: boolean;
+                        readonly unavailable: number;
+                        readonly matched: number;
+                        readonly mismatched: number;
+                        readonly knownTotal: number | null;
+                        readonly examined: number;
+                        readonly exhaustive: boolean;
+                        readonly decisive: boolean;
+                    } | undefined;
+                    readonly observed: import("../assertions/record/model.js").AssertionFactValue;
                 };
-                readonly evidence: readonly ({
-                    readonly value: import("../assertions/record/model.js").BoundedJsonValue;
-                    readonly kind: "snapshot";
-                } | {
-                    readonly kind: "blob";
-                    readonly ref: RecordBlobRef;
-                    readonly sha256: import("../record/model/identifiers.js").Sha256Digest;
-                    readonly encoding: "utf-8" | "binary";
-                    readonly preview: string;
-                    readonly byteLength: number;
-                })[];
                 readonly display: import("../assertions/record/model.js").AssertionDisplay;
-                readonly criterion: import("../assertions/record/model.js").BoundedJsonObject;
+                readonly criterion: {
+                    readonly value: import("../assertions/record/model.js").BoundedJsonObject;
+                    readonly state: "available";
+                } | {
+                    readonly reason: "not-recorded";
+                    readonly state: "unavailable";
+                };
+                readonly policy: {
+                    readonly condition: {
+                        readonly value: {
+                            readonly expected: true;
+                            readonly kind: "boolean";
+                        } | {
+                            readonly kind: "at-least";
+                            readonly threshold: number;
+                        } | {
+                            readonly kind: "record-only";
+                        };
+                        readonly state: "available";
+                    } | {
+                        readonly reason: "not-recorded";
+                        readonly state: "unavailable";
+                    };
+                    readonly requirement: {
+                        readonly value: "optional" | "required";
+                        readonly state: "available";
+                    } | {
+                        readonly reason: "not-recorded";
+                        readonly state: "unavailable";
+                    };
+                };
+                readonly decision: {
+                    readonly reason: "redacted" | "evidence-unavailable" | "source-unavailable" | "condition-not-met" | "evaluator-failed" | "producer-interrupted" | "invalid-subject" | "coverage-not-applicable" | null;
+                    readonly gate: "failed" | "unavailable" | "not-applicable" | "not-gate" | "satisfied";
+                    readonly result: "errored" | "unavailable" | "matched" | "mismatched" | "not-applicable";
+                };
+                readonly contribution: import("../assertions/record/model.js").NoScoreContribution | import("../assertions/record/model.js").EarnedScoreContribution | import("../assertions/record/model.js").UnavailableScoreContribution;
                 readonly entryId: import("../index.js").AssertionEntryId;
+                readonly materials: {
+                    readonly source: {
+                        readonly reason: "not-recorded";
+                        readonly kind: "unavailable";
+                    } | {
+                        readonly value: import("../assertions/record/model.js").BoundedJsonValue;
+                        readonly kind: "snapshot";
+                    } | {
+                        readonly kind: "blob";
+                        readonly ref: RecordBlobRef;
+                        readonly sha256: import("../record/model/identifiers.js").Sha256Digest;
+                        readonly encoding: "utf-8" | "binary";
+                        readonly preview: string;
+                        readonly byteLength: number;
+                    };
+                    readonly coverage: import("../assertions/record/model.js").AssertionCoverage;
+                    readonly limitations: readonly import("../assertions/record/model.js").AssertionLimitation[];
+                    readonly evidence: readonly ({
+                        readonly reason: "not-recorded";
+                        readonly kind: "unavailable";
+                    } | {
+                        readonly value: import("../assertions/record/model.js").BoundedJsonValue;
+                        readonly kind: "snapshot";
+                    } | {
+                        readonly kind: "blob";
+                        readonly ref: RecordBlobRef;
+                        readonly sha256: import("../record/model/identifiers.js").Sha256Digest;
+                        readonly encoding: "utf-8" | "binary";
+                        readonly preview: string;
+                        readonly byteLength: number;
+                    })[];
+                };
+                readonly explanationRetention: {
+                    readonly value: import("../assertions/record/model.js").AssertionFactValue;
+                    readonly state: "retained";
+                } | {
+                    readonly reason: "not-recorded";
+                    readonly state: "unavailable";
+                };
             }[];
             readonly sourceSites: readonly {
                 readonly role: "gate" | "score" | "declaration" | "threshold" | "optional" | "stop";
@@ -1019,40 +1082,103 @@ export declare const publishedAnalysisInputBindings: Readonly<{
                     readonly line: number;
                     readonly column: number;
                 };
+                readonly entryId: import("../index.js").AssertionEntryId;
                 readonly sourceItemId: import("../record/model/identifiers.js").SourceItemId;
                 readonly sourceOrder: number;
-                readonly entryId: import("../index.js").AssertionEntryId;
             }[];
         }, import("../record/family/catalog.js").FixedRecordFamilyDescriptor<"niceeval.assertions", "attempt", {
             readonly entries: readonly {
-                readonly result: import("../assertions/record/model.js").SealedAssertionResult;
-                readonly coverage: import("../assertions/record/model.js").AssertionCoverage;
-                readonly limitations: readonly import("../assertions/record/model.js").AssertionLimitation[];
-                readonly subject: {
-                    readonly value: import("../assertions/record/model.js").BoundedJsonValue;
-                    readonly kind: "snapshot";
-                } | {
-                    readonly kind: "blob";
-                    readonly ref: RecordBlobRef;
-                    readonly sha256: import("../record/model/identifiers.js").Sha256Digest;
-                    readonly encoding: "utf-8" | "binary";
-                    readonly preview: string;
-                    readonly byteLength: number;
+                readonly evaluation: {
+                    readonly receipt?: {
+                        readonly complete: boolean;
+                        readonly unavailable: number;
+                        readonly matched: number;
+                        readonly mismatched: number;
+                        readonly knownTotal: number | null;
+                        readonly examined: number;
+                        readonly exhaustive: boolean;
+                        readonly decisive: boolean;
+                    } | undefined;
+                    readonly observed: import("../assertions/record/model.js").AssertionFactValue;
                 };
-                readonly evidence: readonly ({
-                    readonly value: import("../assertions/record/model.js").BoundedJsonValue;
-                    readonly kind: "snapshot";
-                } | {
-                    readonly kind: "blob";
-                    readonly ref: RecordBlobRef;
-                    readonly sha256: import("../record/model/identifiers.js").Sha256Digest;
-                    readonly encoding: "utf-8" | "binary";
-                    readonly preview: string;
-                    readonly byteLength: number;
-                })[];
                 readonly display: import("../assertions/record/model.js").AssertionDisplay;
-                readonly criterion: import("../assertions/record/model.js").BoundedJsonObject;
+                readonly criterion: {
+                    readonly value: import("../assertions/record/model.js").BoundedJsonObject;
+                    readonly state: "available";
+                } | {
+                    readonly reason: "not-recorded";
+                    readonly state: "unavailable";
+                };
+                readonly policy: {
+                    readonly condition: {
+                        readonly value: {
+                            readonly expected: true;
+                            readonly kind: "boolean";
+                        } | {
+                            readonly kind: "at-least";
+                            readonly threshold: number;
+                        } | {
+                            readonly kind: "record-only";
+                        };
+                        readonly state: "available";
+                    } | {
+                        readonly reason: "not-recorded";
+                        readonly state: "unavailable";
+                    };
+                    readonly requirement: {
+                        readonly value: "optional" | "required";
+                        readonly state: "available";
+                    } | {
+                        readonly reason: "not-recorded";
+                        readonly state: "unavailable";
+                    };
+                };
+                readonly decision: {
+                    readonly reason: "redacted" | "evidence-unavailable" | "source-unavailable" | "condition-not-met" | "evaluator-failed" | "producer-interrupted" | "invalid-subject" | "coverage-not-applicable" | null;
+                    readonly gate: "failed" | "unavailable" | "not-applicable" | "not-gate" | "satisfied";
+                    readonly result: "errored" | "unavailable" | "matched" | "mismatched" | "not-applicable";
+                };
+                readonly contribution: import("../assertions/record/model.js").NoScoreContribution | import("../assertions/record/model.js").EarnedScoreContribution | import("../assertions/record/model.js").UnavailableScoreContribution;
                 readonly entryId: import("../index.js").AssertionEntryId;
+                readonly materials: {
+                    readonly source: {
+                        readonly reason: "not-recorded";
+                        readonly kind: "unavailable";
+                    } | {
+                        readonly value: import("../assertions/record/model.js").BoundedJsonValue;
+                        readonly kind: "snapshot";
+                    } | {
+                        readonly kind: "blob";
+                        readonly ref: RecordBlobRef;
+                        readonly sha256: import("../record/model/identifiers.js").Sha256Digest;
+                        readonly encoding: "utf-8" | "binary";
+                        readonly preview: string;
+                        readonly byteLength: number;
+                    };
+                    readonly coverage: import("../assertions/record/model.js").AssertionCoverage;
+                    readonly limitations: readonly import("../assertions/record/model.js").AssertionLimitation[];
+                    readonly evidence: readonly ({
+                        readonly reason: "not-recorded";
+                        readonly kind: "unavailable";
+                    } | {
+                        readonly value: import("../assertions/record/model.js").BoundedJsonValue;
+                        readonly kind: "snapshot";
+                    } | {
+                        readonly kind: "blob";
+                        readonly ref: RecordBlobRef;
+                        readonly sha256: import("../record/model/identifiers.js").Sha256Digest;
+                        readonly encoding: "utf-8" | "binary";
+                        readonly preview: string;
+                        readonly byteLength: number;
+                    })[];
+                };
+                readonly explanationRetention: {
+                    readonly value: import("../assertions/record/model.js").AssertionFactValue;
+                    readonly state: "retained";
+                } | {
+                    readonly reason: "not-recorded";
+                    readonly state: "unavailable";
+                };
             }[];
             readonly sourceSites: readonly {
                 readonly role: "gate" | "score" | "declaration" | "threshold" | "optional" | "stop";
@@ -1065,9 +1191,9 @@ export declare const publishedAnalysisInputBindings: Readonly<{
                     readonly line: number;
                     readonly column: number;
                 };
+                readonly entryId: import("../index.js").AssertionEntryId;
                 readonly sourceItemId: import("../record/model/identifiers.js").SourceItemId;
                 readonly sourceOrder: number;
-                readonly entryId: import("../index.js").AssertionEntryId;
             }[];
         }>>;
         project: ({ core, payload }: {
@@ -3857,34 +3983,97 @@ export declare const attemptEvidenceDomainBinding: Readonly<{
     kind: "attempt-evidence";
     family: FixedFamilyBinding<"attempt", {
         readonly entries: readonly {
-            readonly result: import("../assertions/record/model.js").SealedAssertionResult;
-            readonly coverage: import("../assertions/record/model.js").AssertionCoverage;
-            readonly limitations: readonly import("../assertions/record/model.js").AssertionLimitation[];
-            readonly subject: {
-                readonly value: import("../assertions/record/model.js").BoundedJsonValue;
-                readonly kind: "snapshot";
-            } | {
-                readonly kind: "blob";
-                readonly ref: RecordBlobRef;
-                readonly sha256: import("../record/model/identifiers.js").Sha256Digest;
-                readonly encoding: "utf-8" | "binary";
-                readonly preview: string;
-                readonly byteLength: number;
+            readonly evaluation: {
+                readonly receipt?: {
+                    readonly complete: boolean;
+                    readonly unavailable: number;
+                    readonly matched: number;
+                    readonly mismatched: number;
+                    readonly knownTotal: number | null;
+                    readonly examined: number;
+                    readonly exhaustive: boolean;
+                    readonly decisive: boolean;
+                } | undefined;
+                readonly observed: import("../assertions/record/model.js").AssertionFactValue;
             };
-            readonly evidence: readonly ({
-                readonly value: import("../assertions/record/model.js").BoundedJsonValue;
-                readonly kind: "snapshot";
-            } | {
-                readonly kind: "blob";
-                readonly ref: RecordBlobRef;
-                readonly sha256: import("../record/model/identifiers.js").Sha256Digest;
-                readonly encoding: "utf-8" | "binary";
-                readonly preview: string;
-                readonly byteLength: number;
-            })[];
             readonly display: import("../assertions/record/model.js").AssertionDisplay;
-            readonly criterion: import("../assertions/record/model.js").BoundedJsonObject;
+            readonly criterion: {
+                readonly value: import("../assertions/record/model.js").BoundedJsonObject;
+                readonly state: "available";
+            } | {
+                readonly reason: "not-recorded";
+                readonly state: "unavailable";
+            };
+            readonly policy: {
+                readonly condition: {
+                    readonly value: {
+                        readonly expected: true;
+                        readonly kind: "boolean";
+                    } | {
+                        readonly kind: "at-least";
+                        readonly threshold: number;
+                    } | {
+                        readonly kind: "record-only";
+                    };
+                    readonly state: "available";
+                } | {
+                    readonly reason: "not-recorded";
+                    readonly state: "unavailable";
+                };
+                readonly requirement: {
+                    readonly value: "optional" | "required";
+                    readonly state: "available";
+                } | {
+                    readonly reason: "not-recorded";
+                    readonly state: "unavailable";
+                };
+            };
+            readonly decision: {
+                readonly reason: "redacted" | "evidence-unavailable" | "source-unavailable" | "condition-not-met" | "evaluator-failed" | "producer-interrupted" | "invalid-subject" | "coverage-not-applicable" | null;
+                readonly gate: "failed" | "unavailable" | "not-applicable" | "not-gate" | "satisfied";
+                readonly result: "errored" | "unavailable" | "matched" | "mismatched" | "not-applicable";
+            };
+            readonly contribution: import("../assertions/record/model.js").NoScoreContribution | import("../assertions/record/model.js").EarnedScoreContribution | import("../assertions/record/model.js").UnavailableScoreContribution;
             readonly entryId: import("../index.js").AssertionEntryId;
+            readonly materials: {
+                readonly source: {
+                    readonly reason: "not-recorded";
+                    readonly kind: "unavailable";
+                } | {
+                    readonly value: import("../assertions/record/model.js").BoundedJsonValue;
+                    readonly kind: "snapshot";
+                } | {
+                    readonly kind: "blob";
+                    readonly ref: RecordBlobRef;
+                    readonly sha256: import("../record/model/identifiers.js").Sha256Digest;
+                    readonly encoding: "utf-8" | "binary";
+                    readonly preview: string;
+                    readonly byteLength: number;
+                };
+                readonly coverage: import("../assertions/record/model.js").AssertionCoverage;
+                readonly limitations: readonly import("../assertions/record/model.js").AssertionLimitation[];
+                readonly evidence: readonly ({
+                    readonly reason: "not-recorded";
+                    readonly kind: "unavailable";
+                } | {
+                    readonly value: import("../assertions/record/model.js").BoundedJsonValue;
+                    readonly kind: "snapshot";
+                } | {
+                    readonly kind: "blob";
+                    readonly ref: RecordBlobRef;
+                    readonly sha256: import("../record/model/identifiers.js").Sha256Digest;
+                    readonly encoding: "utf-8" | "binary";
+                    readonly preview: string;
+                    readonly byteLength: number;
+                })[];
+            };
+            readonly explanationRetention: {
+                readonly value: import("../assertions/record/model.js").AssertionFactValue;
+                readonly state: "retained";
+            } | {
+                readonly reason: "not-recorded";
+                readonly state: "unavailable";
+            };
         }[];
         readonly sourceSites: readonly {
             readonly role: "gate" | "score" | "declaration" | "threshold" | "optional" | "stop";
@@ -3897,40 +4086,103 @@ export declare const attemptEvidenceDomainBinding: Readonly<{
                 readonly line: number;
                 readonly column: number;
             };
+            readonly entryId: import("../index.js").AssertionEntryId;
             readonly sourceItemId: import("../record/model/identifiers.js").SourceItemId;
             readonly sourceOrder: number;
-            readonly entryId: import("../index.js").AssertionEntryId;
         }[];
     }, import("../record/family/catalog.js").FixedRecordFamilyDescriptor<"niceeval.assertions", "attempt", {
         readonly entries: readonly {
-            readonly result: import("../assertions/record/model.js").SealedAssertionResult;
-            readonly coverage: import("../assertions/record/model.js").AssertionCoverage;
-            readonly limitations: readonly import("../assertions/record/model.js").AssertionLimitation[];
-            readonly subject: {
-                readonly value: import("../assertions/record/model.js").BoundedJsonValue;
-                readonly kind: "snapshot";
-            } | {
-                readonly kind: "blob";
-                readonly ref: RecordBlobRef;
-                readonly sha256: import("../record/model/identifiers.js").Sha256Digest;
-                readonly encoding: "utf-8" | "binary";
-                readonly preview: string;
-                readonly byteLength: number;
+            readonly evaluation: {
+                readonly receipt?: {
+                    readonly complete: boolean;
+                    readonly unavailable: number;
+                    readonly matched: number;
+                    readonly mismatched: number;
+                    readonly knownTotal: number | null;
+                    readonly examined: number;
+                    readonly exhaustive: boolean;
+                    readonly decisive: boolean;
+                } | undefined;
+                readonly observed: import("../assertions/record/model.js").AssertionFactValue;
             };
-            readonly evidence: readonly ({
-                readonly value: import("../assertions/record/model.js").BoundedJsonValue;
-                readonly kind: "snapshot";
-            } | {
-                readonly kind: "blob";
-                readonly ref: RecordBlobRef;
-                readonly sha256: import("../record/model/identifiers.js").Sha256Digest;
-                readonly encoding: "utf-8" | "binary";
-                readonly preview: string;
-                readonly byteLength: number;
-            })[];
             readonly display: import("../assertions/record/model.js").AssertionDisplay;
-            readonly criterion: import("../assertions/record/model.js").BoundedJsonObject;
+            readonly criterion: {
+                readonly value: import("../assertions/record/model.js").BoundedJsonObject;
+                readonly state: "available";
+            } | {
+                readonly reason: "not-recorded";
+                readonly state: "unavailable";
+            };
+            readonly policy: {
+                readonly condition: {
+                    readonly value: {
+                        readonly expected: true;
+                        readonly kind: "boolean";
+                    } | {
+                        readonly kind: "at-least";
+                        readonly threshold: number;
+                    } | {
+                        readonly kind: "record-only";
+                    };
+                    readonly state: "available";
+                } | {
+                    readonly reason: "not-recorded";
+                    readonly state: "unavailable";
+                };
+                readonly requirement: {
+                    readonly value: "optional" | "required";
+                    readonly state: "available";
+                } | {
+                    readonly reason: "not-recorded";
+                    readonly state: "unavailable";
+                };
+            };
+            readonly decision: {
+                readonly reason: "redacted" | "evidence-unavailable" | "source-unavailable" | "condition-not-met" | "evaluator-failed" | "producer-interrupted" | "invalid-subject" | "coverage-not-applicable" | null;
+                readonly gate: "failed" | "unavailable" | "not-applicable" | "not-gate" | "satisfied";
+                readonly result: "errored" | "unavailable" | "matched" | "mismatched" | "not-applicable";
+            };
+            readonly contribution: import("../assertions/record/model.js").NoScoreContribution | import("../assertions/record/model.js").EarnedScoreContribution | import("../assertions/record/model.js").UnavailableScoreContribution;
             readonly entryId: import("../index.js").AssertionEntryId;
+            readonly materials: {
+                readonly source: {
+                    readonly reason: "not-recorded";
+                    readonly kind: "unavailable";
+                } | {
+                    readonly value: import("../assertions/record/model.js").BoundedJsonValue;
+                    readonly kind: "snapshot";
+                } | {
+                    readonly kind: "blob";
+                    readonly ref: RecordBlobRef;
+                    readonly sha256: import("../record/model/identifiers.js").Sha256Digest;
+                    readonly encoding: "utf-8" | "binary";
+                    readonly preview: string;
+                    readonly byteLength: number;
+                };
+                readonly coverage: import("../assertions/record/model.js").AssertionCoverage;
+                readonly limitations: readonly import("../assertions/record/model.js").AssertionLimitation[];
+                readonly evidence: readonly ({
+                    readonly reason: "not-recorded";
+                    readonly kind: "unavailable";
+                } | {
+                    readonly value: import("../assertions/record/model.js").BoundedJsonValue;
+                    readonly kind: "snapshot";
+                } | {
+                    readonly kind: "blob";
+                    readonly ref: RecordBlobRef;
+                    readonly sha256: import("../record/model/identifiers.js").Sha256Digest;
+                    readonly encoding: "utf-8" | "binary";
+                    readonly preview: string;
+                    readonly byteLength: number;
+                })[];
+            };
+            readonly explanationRetention: {
+                readonly value: import("../assertions/record/model.js").AssertionFactValue;
+                readonly state: "retained";
+            } | {
+                readonly reason: "not-recorded";
+                readonly state: "unavailable";
+            };
         }[];
         readonly sourceSites: readonly {
             readonly role: "gate" | "score" | "declaration" | "threshold" | "optional" | "stop";
@@ -3943,9 +4195,9 @@ export declare const attemptEvidenceDomainBinding: Readonly<{
                 readonly line: number;
                 readonly column: number;
             };
+            readonly entryId: import("../index.js").AssertionEntryId;
             readonly sourceItemId: import("../record/model/identifiers.js").SourceItemId;
             readonly sourceOrder: number;
-            readonly entryId: import("../index.js").AssertionEntryId;
         }[];
     }>>;
     project: ({ core, payload, blobs }: {
@@ -6149,34 +6401,97 @@ export declare const builtinDomainViewBindings: Readonly<{
         kind: "attempt-evidence";
         family: FixedFamilyBinding<"attempt", {
             readonly entries: readonly {
-                readonly result: import("../assertions/record/model.js").SealedAssertionResult;
-                readonly coverage: import("../assertions/record/model.js").AssertionCoverage;
-                readonly limitations: readonly import("../assertions/record/model.js").AssertionLimitation[];
-                readonly subject: {
-                    readonly value: import("../assertions/record/model.js").BoundedJsonValue;
-                    readonly kind: "snapshot";
-                } | {
-                    readonly kind: "blob";
-                    readonly ref: RecordBlobRef;
-                    readonly sha256: import("../record/model/identifiers.js").Sha256Digest;
-                    readonly encoding: "utf-8" | "binary";
-                    readonly preview: string;
-                    readonly byteLength: number;
+                readonly evaluation: {
+                    readonly receipt?: {
+                        readonly complete: boolean;
+                        readonly unavailable: number;
+                        readonly matched: number;
+                        readonly mismatched: number;
+                        readonly knownTotal: number | null;
+                        readonly examined: number;
+                        readonly exhaustive: boolean;
+                        readonly decisive: boolean;
+                    } | undefined;
+                    readonly observed: import("../assertions/record/model.js").AssertionFactValue;
                 };
-                readonly evidence: readonly ({
-                    readonly value: import("../assertions/record/model.js").BoundedJsonValue;
-                    readonly kind: "snapshot";
-                } | {
-                    readonly kind: "blob";
-                    readonly ref: RecordBlobRef;
-                    readonly sha256: import("../record/model/identifiers.js").Sha256Digest;
-                    readonly encoding: "utf-8" | "binary";
-                    readonly preview: string;
-                    readonly byteLength: number;
-                })[];
                 readonly display: import("../assertions/record/model.js").AssertionDisplay;
-                readonly criterion: import("../assertions/record/model.js").BoundedJsonObject;
+                readonly criterion: {
+                    readonly value: import("../assertions/record/model.js").BoundedJsonObject;
+                    readonly state: "available";
+                } | {
+                    readonly reason: "not-recorded";
+                    readonly state: "unavailable";
+                };
+                readonly policy: {
+                    readonly condition: {
+                        readonly value: {
+                            readonly expected: true;
+                            readonly kind: "boolean";
+                        } | {
+                            readonly kind: "at-least";
+                            readonly threshold: number;
+                        } | {
+                            readonly kind: "record-only";
+                        };
+                        readonly state: "available";
+                    } | {
+                        readonly reason: "not-recorded";
+                        readonly state: "unavailable";
+                    };
+                    readonly requirement: {
+                        readonly value: "optional" | "required";
+                        readonly state: "available";
+                    } | {
+                        readonly reason: "not-recorded";
+                        readonly state: "unavailable";
+                    };
+                };
+                readonly decision: {
+                    readonly reason: "redacted" | "evidence-unavailable" | "source-unavailable" | "condition-not-met" | "evaluator-failed" | "producer-interrupted" | "invalid-subject" | "coverage-not-applicable" | null;
+                    readonly gate: "failed" | "unavailable" | "not-applicable" | "not-gate" | "satisfied";
+                    readonly result: "errored" | "unavailable" | "matched" | "mismatched" | "not-applicable";
+                };
+                readonly contribution: import("../assertions/record/model.js").NoScoreContribution | import("../assertions/record/model.js").EarnedScoreContribution | import("../assertions/record/model.js").UnavailableScoreContribution;
                 readonly entryId: import("../index.js").AssertionEntryId;
+                readonly materials: {
+                    readonly source: {
+                        readonly reason: "not-recorded";
+                        readonly kind: "unavailable";
+                    } | {
+                        readonly value: import("../assertions/record/model.js").BoundedJsonValue;
+                        readonly kind: "snapshot";
+                    } | {
+                        readonly kind: "blob";
+                        readonly ref: RecordBlobRef;
+                        readonly sha256: import("../record/model/identifiers.js").Sha256Digest;
+                        readonly encoding: "utf-8" | "binary";
+                        readonly preview: string;
+                        readonly byteLength: number;
+                    };
+                    readonly coverage: import("../assertions/record/model.js").AssertionCoverage;
+                    readonly limitations: readonly import("../assertions/record/model.js").AssertionLimitation[];
+                    readonly evidence: readonly ({
+                        readonly reason: "not-recorded";
+                        readonly kind: "unavailable";
+                    } | {
+                        readonly value: import("../assertions/record/model.js").BoundedJsonValue;
+                        readonly kind: "snapshot";
+                    } | {
+                        readonly kind: "blob";
+                        readonly ref: RecordBlobRef;
+                        readonly sha256: import("../record/model/identifiers.js").Sha256Digest;
+                        readonly encoding: "utf-8" | "binary";
+                        readonly preview: string;
+                        readonly byteLength: number;
+                    })[];
+                };
+                readonly explanationRetention: {
+                    readonly value: import("../assertions/record/model.js").AssertionFactValue;
+                    readonly state: "retained";
+                } | {
+                    readonly reason: "not-recorded";
+                    readonly state: "unavailable";
+                };
             }[];
             readonly sourceSites: readonly {
                 readonly role: "gate" | "score" | "declaration" | "threshold" | "optional" | "stop";
@@ -6189,40 +6504,103 @@ export declare const builtinDomainViewBindings: Readonly<{
                     readonly line: number;
                     readonly column: number;
                 };
+                readonly entryId: import("../index.js").AssertionEntryId;
                 readonly sourceItemId: import("../record/model/identifiers.js").SourceItemId;
                 readonly sourceOrder: number;
-                readonly entryId: import("../index.js").AssertionEntryId;
             }[];
         }, import("../record/family/catalog.js").FixedRecordFamilyDescriptor<"niceeval.assertions", "attempt", {
             readonly entries: readonly {
-                readonly result: import("../assertions/record/model.js").SealedAssertionResult;
-                readonly coverage: import("../assertions/record/model.js").AssertionCoverage;
-                readonly limitations: readonly import("../assertions/record/model.js").AssertionLimitation[];
-                readonly subject: {
-                    readonly value: import("../assertions/record/model.js").BoundedJsonValue;
-                    readonly kind: "snapshot";
-                } | {
-                    readonly kind: "blob";
-                    readonly ref: RecordBlobRef;
-                    readonly sha256: import("../record/model/identifiers.js").Sha256Digest;
-                    readonly encoding: "utf-8" | "binary";
-                    readonly preview: string;
-                    readonly byteLength: number;
+                readonly evaluation: {
+                    readonly receipt?: {
+                        readonly complete: boolean;
+                        readonly unavailable: number;
+                        readonly matched: number;
+                        readonly mismatched: number;
+                        readonly knownTotal: number | null;
+                        readonly examined: number;
+                        readonly exhaustive: boolean;
+                        readonly decisive: boolean;
+                    } | undefined;
+                    readonly observed: import("../assertions/record/model.js").AssertionFactValue;
                 };
-                readonly evidence: readonly ({
-                    readonly value: import("../assertions/record/model.js").BoundedJsonValue;
-                    readonly kind: "snapshot";
-                } | {
-                    readonly kind: "blob";
-                    readonly ref: RecordBlobRef;
-                    readonly sha256: import("../record/model/identifiers.js").Sha256Digest;
-                    readonly encoding: "utf-8" | "binary";
-                    readonly preview: string;
-                    readonly byteLength: number;
-                })[];
                 readonly display: import("../assertions/record/model.js").AssertionDisplay;
-                readonly criterion: import("../assertions/record/model.js").BoundedJsonObject;
+                readonly criterion: {
+                    readonly value: import("../assertions/record/model.js").BoundedJsonObject;
+                    readonly state: "available";
+                } | {
+                    readonly reason: "not-recorded";
+                    readonly state: "unavailable";
+                };
+                readonly policy: {
+                    readonly condition: {
+                        readonly value: {
+                            readonly expected: true;
+                            readonly kind: "boolean";
+                        } | {
+                            readonly kind: "at-least";
+                            readonly threshold: number;
+                        } | {
+                            readonly kind: "record-only";
+                        };
+                        readonly state: "available";
+                    } | {
+                        readonly reason: "not-recorded";
+                        readonly state: "unavailable";
+                    };
+                    readonly requirement: {
+                        readonly value: "optional" | "required";
+                        readonly state: "available";
+                    } | {
+                        readonly reason: "not-recorded";
+                        readonly state: "unavailable";
+                    };
+                };
+                readonly decision: {
+                    readonly reason: "redacted" | "evidence-unavailable" | "source-unavailable" | "condition-not-met" | "evaluator-failed" | "producer-interrupted" | "invalid-subject" | "coverage-not-applicable" | null;
+                    readonly gate: "failed" | "unavailable" | "not-applicable" | "not-gate" | "satisfied";
+                    readonly result: "errored" | "unavailable" | "matched" | "mismatched" | "not-applicable";
+                };
+                readonly contribution: import("../assertions/record/model.js").NoScoreContribution | import("../assertions/record/model.js").EarnedScoreContribution | import("../assertions/record/model.js").UnavailableScoreContribution;
                 readonly entryId: import("../index.js").AssertionEntryId;
+                readonly materials: {
+                    readonly source: {
+                        readonly reason: "not-recorded";
+                        readonly kind: "unavailable";
+                    } | {
+                        readonly value: import("../assertions/record/model.js").BoundedJsonValue;
+                        readonly kind: "snapshot";
+                    } | {
+                        readonly kind: "blob";
+                        readonly ref: RecordBlobRef;
+                        readonly sha256: import("../record/model/identifiers.js").Sha256Digest;
+                        readonly encoding: "utf-8" | "binary";
+                        readonly preview: string;
+                        readonly byteLength: number;
+                    };
+                    readonly coverage: import("../assertions/record/model.js").AssertionCoverage;
+                    readonly limitations: readonly import("../assertions/record/model.js").AssertionLimitation[];
+                    readonly evidence: readonly ({
+                        readonly reason: "not-recorded";
+                        readonly kind: "unavailable";
+                    } | {
+                        readonly value: import("../assertions/record/model.js").BoundedJsonValue;
+                        readonly kind: "snapshot";
+                    } | {
+                        readonly kind: "blob";
+                        readonly ref: RecordBlobRef;
+                        readonly sha256: import("../record/model/identifiers.js").Sha256Digest;
+                        readonly encoding: "utf-8" | "binary";
+                        readonly preview: string;
+                        readonly byteLength: number;
+                    })[];
+                };
+                readonly explanationRetention: {
+                    readonly value: import("../assertions/record/model.js").AssertionFactValue;
+                    readonly state: "retained";
+                } | {
+                    readonly reason: "not-recorded";
+                    readonly state: "unavailable";
+                };
             }[];
             readonly sourceSites: readonly {
                 readonly role: "gate" | "score" | "declaration" | "threshold" | "optional" | "stop";
@@ -6235,9 +6613,9 @@ export declare const builtinDomainViewBindings: Readonly<{
                     readonly line: number;
                     readonly column: number;
                 };
+                readonly entryId: import("../index.js").AssertionEntryId;
                 readonly sourceItemId: import("../record/model/identifiers.js").SourceItemId;
                 readonly sourceOrder: number;
-                readonly entryId: import("../index.js").AssertionEntryId;
             }[];
         }>>;
         project: ({ core, payload, blobs }: {