niceeval 0.13.2 → 0.13.3

package/dist/assertions/record/attachment.d.ts

@@ -5,9 +5,12 @@ import type { Sha256Digest } from "../../record/model/identifiers.js";
 import type { AssertionResult, SealedAssertionEntry } from "../api.js";
 import { type ThirdPartyCriterionRegistry } from "./codec.js";
 import { type AssertionEntryInput, type AssertionsEntryIdSource, type AssertionsProducerError } from "./producer.js";
-import type { AssertionEntryId, AssertionCoverage as RecordAssertionCoverage, AssertionLimitation as RecordAssertionLimitation, AssertionsDocumentOuter, AssertionsProjection, BoundedJsonObject, BoundedJsonValue, SealedAssertionResult, WritableCriterionEnvelope } from "./model.js";
+import type { AssertionEntryId, AssertionFactValue, AssertionCoverage as RecordAssertionCoverage, AssertionLimitation as RecordAssertionLimitation, AssertionsDocumentOuter, AssertionsProjection, BoundedJsonObject, BoundedJsonValue, SealedAssertionResult, WritableCriterionEnvelope } from "./model.js";
 export declare const assertionsRecordSchemas: Readonly<{
     material: Schema.Union<[Schema.Struct<{
+        kind: Schema.Literal<["unavailable"]>;
+        reason: Schema.Literal<["not-recorded"]>;
+    }>, Schema.Struct<{
         kind: Schema.Literal<["snapshot"]>;
         value: Schema.Schema<BoundedJsonValue, BoundedJsonValue, never>;
     }>, Schema.Struct<{
@@ -18,11 +21,107 @@ export declare const assertionsRecordSchemas: Readonly<{
         sha256: Schema.Schema<Sha256Digest, string, never>;
         preview: Schema.filter<typeof Schema.String>;
     }>]>;
-    entries: Schema.filter<Schema.Array$<Schema.filter<Schema.Struct<{
+    entries: Schema.filter<Schema.Array$<Schema.Struct<{
+        entryId: Schema.Schema<AssertionEntryId, string, never>;
+        display: Schema.Schema<import("./model.js").AssertionDisplay, import("./model.js").AssertionDisplay, never>;
+        criterion: Schema.Union<[Schema.Struct<{
+            state: Schema.Literal<["available"]>;
+            value: Schema.Schema<BoundedJsonObject, BoundedJsonObject, never>;
+        }>, Schema.Struct<{
+            state: Schema.Literal<["unavailable"]>;
+            reason: Schema.Literal<["not-recorded"]>;
+        }>]>;
+        materials: Schema.filter<Schema.Struct<{
+            source: Schema.Union<[Schema.Struct<{
+                kind: Schema.Literal<["unavailable"]>;
+                reason: Schema.Literal<["not-recorded"]>;
+            }>, Schema.Struct<{
+                kind: Schema.Literal<["snapshot"]>;
+                value: Schema.Schema<BoundedJsonValue, BoundedJsonValue, never>;
+            }>, Schema.Struct<{
+                kind: Schema.Literal<["blob"]>;
+                ref: Schema.Schema<RecordBlobRef, RecordBlobRef, never>;
+                encoding: Schema.Literal<["utf-8", "binary"]>;
+                byteLength: Schema.filter<typeof Schema.JsonNumber>;
+                sha256: Schema.Schema<Sha256Digest, string, never>;
+                preview: Schema.filter<typeof Schema.String>;
+            }>]>;
+            evidence: Schema.Array$<Schema.Union<[Schema.Struct<{
+                kind: Schema.Literal<["unavailable"]>;
+                reason: Schema.Literal<["not-recorded"]>;
+            }>, Schema.Struct<{
+                kind: Schema.Literal<["snapshot"]>;
+                value: Schema.Schema<BoundedJsonValue, BoundedJsonValue, never>;
+            }>, Schema.Struct<{
+                kind: Schema.Literal<["blob"]>;
+                ref: Schema.Schema<RecordBlobRef, RecordBlobRef, never>;
+                encoding: Schema.Literal<["utf-8", "binary"]>;
+                byteLength: Schema.filter<typeof Schema.JsonNumber>;
+                sha256: Schema.Schema<Sha256Digest, string, never>;
+                preview: Schema.filter<typeof Schema.String>;
+            }>]>>;
+            coverage: Schema.Schema<RecordAssertionCoverage, RecordAssertionCoverage, never>;
+            limitations: Schema.Array$<Schema.Schema<RecordAssertionLimitation, RecordAssertionLimitation, never>>;
+        }>>;
+        evaluation: Schema.Struct<{
+            observed: Schema.Schema<AssertionFactValue, AssertionFactValue, never>;
+            receipt: Schema.optional<Schema.Struct<{
+                examined: Schema.filter<typeof Schema.JsonNumber>;
+                matched: Schema.filter<typeof Schema.JsonNumber>;
+                mismatched: Schema.filter<typeof Schema.JsonNumber>;
+                unavailable: Schema.filter<typeof Schema.JsonNumber>;
+                knownTotal: Schema.NullOr<Schema.filter<typeof Schema.JsonNumber>>;
+                complete: typeof Schema.Boolean;
+                exhaustive: typeof Schema.Boolean;
+                decisive: typeof Schema.Boolean;
+            }>>;
+        }>;
+        decision: Schema.Struct<{
+            result: Schema.Literal<["matched", "mismatched", "unavailable", "errored", "not-applicable"]>;
+            reason: Schema.NullOr<Schema.Literal<["condition-not-met", "evidence-unavailable", "source-unavailable", "redacted", "evaluator-failed", "producer-interrupted", "invalid-subject", "coverage-not-applicable"]>>;
+            gate: Schema.Literal<["not-gate", "satisfied", "failed", "unavailable", "not-applicable"]>;
+        }>;
+        policy: Schema.Struct<{
+            requirement: Schema.Union<[Schema.Struct<{
+                state: Schema.Literal<["available"]>;
+                value: Schema.Literal<["required", "optional"]>;
+            }>, Schema.Struct<{
+                state: Schema.Literal<["unavailable"]>;
+                reason: Schema.Literal<["not-recorded"]>;
+            }>]>;
+            condition: Schema.Union<[Schema.Struct<{
+                state: Schema.Literal<["available"]>;
+                value: Schema.Union<[Schema.Struct<{
+                    kind: Schema.Literal<["boolean"]>;
+                    expected: Schema.Literal<[true]>;
+                }>, Schema.Struct<{
+                    kind: Schema.Literal<["at-least"]>;
+                    threshold: Schema.filter<typeof Schema.JsonNumber>;
+                }>, Schema.Struct<{
+                    kind: Schema.Literal<["record-only"]>;
+                }>]>;
+            }>, Schema.Struct<{
+                state: Schema.Literal<["unavailable"]>;
+                reason: Schema.Literal<["not-recorded"]>;
+            }>]>;
+        }>;
+        contribution: Schema.Union<[Schema.Schema<import("./model.js").NoScoreContribution, import("./model.js").NoScoreContribution, never>, Schema.Schema<import("./model.js").EarnedScoreContribution, import("./model.js").EarnedScoreContribution, never>, Schema.Schema<import("./model.js").UnavailableScoreContribution, import("./model.js").UnavailableScoreContribution, never>]>;
+        explanationRetention: Schema.Union<[Schema.Struct<{
+            state: Schema.Literal<["retained"]>;
+            value: Schema.Schema<AssertionFactValue, AssertionFactValue, never>;
+        }>, Schema.Struct<{
+            state: Schema.Literal<["unavailable"]>;
+            reason: Schema.Literal<["not-recorded"]>;
+        }>]>;
+    }>>>;
+    historicalEntries: Schema.filter<Schema.Array$<Schema.filter<Schema.Struct<{
         entryId: Schema.Schema<AssertionEntryId, string, never>;
         display: Schema.Schema<import("./model.js").AssertionDisplay, import("./model.js").AssertionDisplay, never>;
         criterion: Schema.Schema<BoundedJsonObject, BoundedJsonObject, never>;
         subject: Schema.Union<[Schema.Struct<{
+            kind: Schema.Literal<["unavailable"]>;
+            reason: Schema.Literal<["not-recorded"]>;
+        }>, Schema.Struct<{
             kind: Schema.Literal<["snapshot"]>;
             value: Schema.Schema<BoundedJsonValue, BoundedJsonValue, never>;
         }>, Schema.Struct<{
@@ -34,6 +133,9 @@ export declare const assertionsRecordSchemas: Readonly<{
             preview: Schema.filter<typeof Schema.String>;
         }>]>;
         evidence: Schema.Array$<Schema.Union<[Schema.Struct<{
+            kind: Schema.Literal<["unavailable"]>;
+            reason: Schema.Literal<["not-recorded"]>;
+        }>, Schema.Struct<{
             kind: Schema.Literal<["snapshot"]>;
             value: Schema.Schema<BoundedJsonValue, BoundedJsonValue, never>;
         }>, Schema.Struct<{
@@ -49,73 +151,202 @@ export declare const assertionsRecordSchemas: Readonly<{
         result: Schema.Schema<SealedAssertionResult, SealedAssertionResult, never>;
     }>>>>;
     outerDocument: Schema.filter<Schema.filter<Schema.Struct<{
-        entries: Schema.filter<Schema.Array$<Schema.filter<Schema.Struct<{
+        entries: Schema.filter<Schema.Array$<Schema.Struct<{
             entryId: Schema.Schema<AssertionEntryId, string, never>;
             display: Schema.Schema<import("./model.js").AssertionDisplay, import("./model.js").AssertionDisplay, never>;
-            criterion: Schema.Schema<BoundedJsonObject, BoundedJsonObject, never>;
-            subject: Schema.Union<[Schema.Struct<{
-                kind: Schema.Literal<["snapshot"]>;
-                value: Schema.Schema<BoundedJsonValue, BoundedJsonValue, never>;
+            criterion: Schema.Union<[Schema.Struct<{
+                state: Schema.Literal<["available"]>;
+                value: Schema.Schema<BoundedJsonObject, BoundedJsonObject, never>;
             }>, Schema.Struct<{
-                kind: Schema.Literal<["blob"]>;
-                ref: Schema.Schema<RecordBlobRef, RecordBlobRef, never>;
-                encoding: Schema.Literal<["utf-8", "binary"]>;
-                byteLength: Schema.filter<typeof Schema.JsonNumber>;
-                sha256: Schema.Schema<Sha256Digest, string, never>;
-                preview: Schema.filter<typeof Schema.String>;
+                state: Schema.Literal<["unavailable"]>;
+                reason: Schema.Literal<["not-recorded"]>;
             }>]>;
-            evidence: Schema.Array$<Schema.Union<[Schema.Struct<{
-                kind: Schema.Literal<["snapshot"]>;
-                value: Schema.Schema<BoundedJsonValue, BoundedJsonValue, never>;
+            materials: Schema.filter<Schema.Struct<{
+                source: Schema.Union<[Schema.Struct<{
+                    kind: Schema.Literal<["unavailable"]>;
+                    reason: Schema.Literal<["not-recorded"]>;
+                }>, Schema.Struct<{
+                    kind: Schema.Literal<["snapshot"]>;
+                    value: Schema.Schema<BoundedJsonValue, BoundedJsonValue, never>;
+                }>, Schema.Struct<{
+                    kind: Schema.Literal<["blob"]>;
+                    ref: Schema.Schema<RecordBlobRef, RecordBlobRef, never>;
+                    encoding: Schema.Literal<["utf-8", "binary"]>;
+                    byteLength: Schema.filter<typeof Schema.JsonNumber>;
+                    sha256: Schema.Schema<Sha256Digest, string, never>;
+                    preview: Schema.filter<typeof Schema.String>;
+                }>]>;
+                evidence: Schema.Array$<Schema.Union<[Schema.Struct<{
+                    kind: Schema.Literal<["unavailable"]>;
+                    reason: Schema.Literal<["not-recorded"]>;
+                }>, Schema.Struct<{
+                    kind: Schema.Literal<["snapshot"]>;
+                    value: Schema.Schema<BoundedJsonValue, BoundedJsonValue, never>;
+                }>, Schema.Struct<{
+                    kind: Schema.Literal<["blob"]>;
+                    ref: Schema.Schema<RecordBlobRef, RecordBlobRef, never>;
+                    encoding: Schema.Literal<["utf-8", "binary"]>;
+                    byteLength: Schema.filter<typeof Schema.JsonNumber>;
+                    sha256: Schema.Schema<Sha256Digest, string, never>;
+                    preview: Schema.filter<typeof Schema.String>;
+                }>]>>;
+                coverage: Schema.Schema<RecordAssertionCoverage, RecordAssertionCoverage, never>;
+                limitations: Schema.Array$<Schema.Schema<RecordAssertionLimitation, RecordAssertionLimitation, never>>;
+            }>>;
+            evaluation: Schema.Struct<{
+                observed: Schema.Schema<AssertionFactValue, AssertionFactValue, never>;
+                receipt: Schema.optional<Schema.Struct<{
+                    examined: Schema.filter<typeof Schema.JsonNumber>;
+                    matched: Schema.filter<typeof Schema.JsonNumber>;
+                    mismatched: Schema.filter<typeof Schema.JsonNumber>;
+                    unavailable: Schema.filter<typeof Schema.JsonNumber>;
+                    knownTotal: Schema.NullOr<Schema.filter<typeof Schema.JsonNumber>>;
+                    complete: typeof Schema.Boolean;
+                    exhaustive: typeof Schema.Boolean;
+                    decisive: typeof Schema.Boolean;
+                }>>;
+            }>;
+            decision: Schema.Struct<{
+                result: Schema.Literal<["matched", "mismatched", "unavailable", "errored", "not-applicable"]>;
+                reason: Schema.NullOr<Schema.Literal<["condition-not-met", "evidence-unavailable", "source-unavailable", "redacted", "evaluator-failed", "producer-interrupted", "invalid-subject", "coverage-not-applicable"]>>;
+                gate: Schema.Literal<["not-gate", "satisfied", "failed", "unavailable", "not-applicable"]>;
+            }>;
+            policy: Schema.Struct<{
+                requirement: Schema.Union<[Schema.Struct<{
+                    state: Schema.Literal<["available"]>;
+                    value: Schema.Literal<["required", "optional"]>;
+                }>, Schema.Struct<{
+                    state: Schema.Literal<["unavailable"]>;
+                    reason: Schema.Literal<["not-recorded"]>;
+                }>]>;
+                condition: Schema.Union<[Schema.Struct<{
+                    state: Schema.Literal<["available"]>;
+                    value: Schema.Union<[Schema.Struct<{
+                        kind: Schema.Literal<["boolean"]>;
+                        expected: Schema.Literal<[true]>;
+                    }>, Schema.Struct<{
+                        kind: Schema.Literal<["at-least"]>;
+                        threshold: Schema.filter<typeof Schema.JsonNumber>;
+                    }>, Schema.Struct<{
+                        kind: Schema.Literal<["record-only"]>;
+                    }>]>;
+                }>, Schema.Struct<{
+                    state: Schema.Literal<["unavailable"]>;
+                    reason: Schema.Literal<["not-recorded"]>;
+                }>]>;
+            }>;
+            contribution: Schema.Union<[Schema.Schema<import("./model.js").NoScoreContribution, import("./model.js").NoScoreContribution, never>, Schema.Schema<import("./model.js").EarnedScoreContribution, import("./model.js").EarnedScoreContribution, never>, Schema.Schema<import("./model.js").UnavailableScoreContribution, import("./model.js").UnavailableScoreContribution, never>]>;
+            explanationRetention: Schema.Union<[Schema.Struct<{
+                state: Schema.Literal<["retained"]>;
+                value: Schema.Schema<AssertionFactValue, AssertionFactValue, never>;
             }>, Schema.Struct<{
-                kind: Schema.Literal<["blob"]>;
-                ref: Schema.Schema<RecordBlobRef, RecordBlobRef, never>;
-                encoding: Schema.Literal<["utf-8", "binary"]>;
-                byteLength: Schema.filter<typeof Schema.JsonNumber>;
-                sha256: Schema.Schema<Sha256Digest, string, never>;
-                preview: Schema.filter<typeof Schema.String>;
-            }>]>>;
-            coverage: Schema.Schema<RecordAssertionCoverage, RecordAssertionCoverage, never>;
-            limitations: Schema.Array$<Schema.Schema<RecordAssertionLimitation, RecordAssertionLimitation, never>>;
-            result: Schema.Schema<SealedAssertionResult, SealedAssertionResult, never>;
-        }>>>>;
+                state: Schema.Literal<["unavailable"]>;
+                reason: Schema.Literal<["not-recorded"]>;
+            }>]>;
+        }>>>;
     }>>>;
     document: Schema.filter<Schema.filter<Schema.Struct<{
-        entries: Schema.filter<Schema.Array$<Schema.filter<Schema.Struct<{
+        entries: Schema.filter<Schema.Array$<Schema.Struct<{
             entryId: Schema.Schema<AssertionEntryId, string, never>;
             display: Schema.Schema<import("./model.js").AssertionDisplay, import("./model.js").AssertionDisplay, never>;
-            criterion: Schema.Schema<WritableCriterionEnvelope, WritableCriterionEnvelope, never>;
-            subject: Schema.Union<[Schema.Struct<{
-                kind: Schema.Literal<["snapshot"]>;
-                value: Schema.Schema<BoundedJsonValue, BoundedJsonValue, never>;
+            criterion: Schema.Union<[Schema.Struct<{
+                state: Schema.Literal<["available"]>;
+                value: Schema.Schema<WritableCriterionEnvelope, WritableCriterionEnvelope, never>;
             }>, Schema.Struct<{
-                kind: Schema.Literal<["blob"]>;
-                ref: Schema.Schema<RecordBlobRef, RecordBlobRef, never>;
-                encoding: Schema.Literal<["utf-8", "binary"]>;
-                byteLength: Schema.filter<typeof Schema.JsonNumber>;
-                sha256: Schema.Schema<Sha256Digest, string, never>;
-                preview: Schema.filter<typeof Schema.String>;
+                state: Schema.Literal<["unavailable"]>;
+                reason: Schema.Literal<["not-recorded"]>;
             }>]>;
-            evidence: Schema.Array$<Schema.Union<[Schema.Struct<{
-                kind: Schema.Literal<["snapshot"]>;
-                value: Schema.Schema<BoundedJsonValue, BoundedJsonValue, never>;
+            materials: Schema.filter<Schema.Struct<{
+                source: Schema.Union<[Schema.Struct<{
+                    kind: Schema.Literal<["unavailable"]>;
+                    reason: Schema.Literal<["not-recorded"]>;
+                }>, Schema.Struct<{
+                    kind: Schema.Literal<["snapshot"]>;
+                    value: Schema.Schema<BoundedJsonValue, BoundedJsonValue, never>;
+                }>, Schema.Struct<{
+                    kind: Schema.Literal<["blob"]>;
+                    ref: Schema.Schema<RecordBlobRef, RecordBlobRef, never>;
+                    encoding: Schema.Literal<["utf-8", "binary"]>;
+                    byteLength: Schema.filter<typeof Schema.JsonNumber>;
+                    sha256: Schema.Schema<Sha256Digest, string, never>;
+                    preview: Schema.filter<typeof Schema.String>;
+                }>]>;
+                evidence: Schema.Array$<Schema.Union<[Schema.Struct<{
+                    kind: Schema.Literal<["unavailable"]>;
+                    reason: Schema.Literal<["not-recorded"]>;
+                }>, Schema.Struct<{
+                    kind: Schema.Literal<["snapshot"]>;
+                    value: Schema.Schema<BoundedJsonValue, BoundedJsonValue, never>;
+                }>, Schema.Struct<{
+                    kind: Schema.Literal<["blob"]>;
+                    ref: Schema.Schema<RecordBlobRef, RecordBlobRef, never>;
+                    encoding: Schema.Literal<["utf-8", "binary"]>;
+                    byteLength: Schema.filter<typeof Schema.JsonNumber>;
+                    sha256: Schema.Schema<Sha256Digest, string, never>;
+                    preview: Schema.filter<typeof Schema.String>;
+                }>]>>;
+                coverage: Schema.Schema<RecordAssertionCoverage, RecordAssertionCoverage, never>;
+                limitations: Schema.Array$<Schema.Schema<RecordAssertionLimitation, RecordAssertionLimitation, never>>;
+            }>>;
+            evaluation: Schema.Struct<{
+                observed: Schema.Schema<AssertionFactValue, AssertionFactValue, never>;
+                receipt: Schema.optional<Schema.Struct<{
+                    examined: Schema.filter<typeof Schema.JsonNumber>;
+                    matched: Schema.filter<typeof Schema.JsonNumber>;
+                    mismatched: Schema.filter<typeof Schema.JsonNumber>;
+                    unavailable: Schema.filter<typeof Schema.JsonNumber>;
+                    knownTotal: Schema.NullOr<Schema.filter<typeof Schema.JsonNumber>>;
+                    complete: typeof Schema.Boolean;
+                    exhaustive: typeof Schema.Boolean;
+                    decisive: typeof Schema.Boolean;
+                }>>;
+            }>;
+            decision: Schema.Struct<{
+                result: Schema.Literal<["matched", "mismatched", "unavailable", "errored", "not-applicable"]>;
+                reason: Schema.NullOr<Schema.Literal<["condition-not-met", "evidence-unavailable", "source-unavailable", "redacted", "evaluator-failed", "producer-interrupted", "invalid-subject", "coverage-not-applicable"]>>;
+                gate: Schema.Literal<["not-gate", "satisfied", "failed", "unavailable", "not-applicable"]>;
+            }>;
+            policy: Schema.Struct<{
+                requirement: Schema.Union<[Schema.Struct<{
+                    state: Schema.Literal<["available"]>;
+                    value: Schema.Literal<["required", "optional"]>;
+                }>, Schema.Struct<{
+                    state: Schema.Literal<["unavailable"]>;
+                    reason: Schema.Literal<["not-recorded"]>;
+                }>]>;
+                condition: Schema.Union<[Schema.Struct<{
+                    state: Schema.Literal<["available"]>;
+                    value: Schema.Union<[Schema.Struct<{
+                        kind: Schema.Literal<["boolean"]>;
+                        expected: Schema.Literal<[true]>;
+                    }>, Schema.Struct<{
+                        kind: Schema.Literal<["at-least"]>;
+                        threshold: Schema.filter<typeof Schema.JsonNumber>;
+                    }>, Schema.Struct<{
+                        kind: Schema.Literal<["record-only"]>;
+                    }>]>;
+                }>, Schema.Struct<{
+                    state: Schema.Literal<["unavailable"]>;
+                    reason: Schema.Literal<["not-recorded"]>;
+                }>]>;
+            }>;
+            contribution: Schema.Union<[Schema.Schema<import("./model.js").NoScoreContribution, import("./model.js").NoScoreContribution, never>, Schema.Schema<import("./model.js").EarnedScoreContribution, import("./model.js").EarnedScoreContribution, never>, Schema.Schema<import("./model.js").UnavailableScoreContribution, import("./model.js").UnavailableScoreContribution, never>]>;
+            explanationRetention: Schema.Union<[Schema.Struct<{
+                state: Schema.Literal<["retained"]>;
+                value: Schema.Schema<AssertionFactValue, AssertionFactValue, never>;
             }>, Schema.Struct<{
-                kind: Schema.Literal<["blob"]>;
-                ref: Schema.Schema<RecordBlobRef, RecordBlobRef, never>;
-                encoding: Schema.Literal<["utf-8", "binary"]>;
-                byteLength: Schema.filter<typeof Schema.JsonNumber>;
-                sha256: Schema.Schema<Sha256Digest, string, never>;
-                preview: Schema.filter<typeof Schema.String>;
-            }>]>>;
-            coverage: Schema.Schema<RecordAssertionCoverage, RecordAssertionCoverage, never>;
-            limitations: Schema.Array$<Schema.Schema<RecordAssertionLimitation, RecordAssertionLimitation, never>>;
-            result: Schema.Schema<SealedAssertionResult, SealedAssertionResult, never>;
-        }>>>>;
+                state: Schema.Literal<["unavailable"]>;
+                reason: Schema.Literal<["not-recorded"]>;
+            }>]>;
+        }>>>;
     }>>>;
 }>;
 /** Complete payload-order projection required by Record's closure validator. */
 export declare function assertionBlobRefs(document: AssertionsDocumentOuter<RecordBlobRef>): readonly RecordBlobRef[];
 export type AssertionMaterialInput<E, R> = {
+    readonly kind: "unavailable";
+    readonly reason: "not-recorded";
+} | {
     readonly kind: "snapshot";
     readonly value: BoundedJsonValue;
 } | {
@@ -130,11 +361,17 @@ export type AssertionMaterialInput<E, R> = {
 export interface AssertionsAttachmentEntryInput<E, R> {
     readonly display: AssertionEntryInput<RecordBlobRef>["display"];
     readonly criterion: AssertionEntryInput<RecordBlobRef>["criterion"];
-    readonly subject: AssertionMaterialInput<E, R>;
-    readonly evidence: readonly AssertionMaterialInput<E, R>[];
-    readonly coverage: AssertionEntryInput<RecordBlobRef>["coverage"];
-    readonly limitations: AssertionEntryInput<RecordBlobRef>["limitations"];
-    readonly result: AssertionEntryInput<RecordBlobRef>["result"];
+    readonly materials: {
+        readonly source: AssertionMaterialInput<E, R>;
+        readonly evidence: readonly AssertionMaterialInput<E, R>[];
+        readonly coverage: AssertionEntryInput<RecordBlobRef>["materials"]["coverage"];
+        readonly limitations: AssertionEntryInput<RecordBlobRef>["materials"]["limitations"];
+    };
+    readonly evaluation: AssertionEntryInput<RecordBlobRef>["evaluation"];
+    readonly decision: AssertionEntryInput<RecordBlobRef>["decision"];
+    readonly policy: AssertionEntryInput<RecordBlobRef>["policy"];
+    readonly contribution: AssertionEntryInput<RecordBlobRef>["contribution"];
+    readonly explanationRetention: AssertionEntryInput<RecordBlobRef>["explanationRetention"];
 }
 export declare function encodeAssertionResult(result: AssertionResult): SealedAssertionResult;
 /** Private Runtime → durable Assertions codec bridge. */

package/dist/assertions/record/codec.cjs

@@ -286,7 +286,10 @@ exports.CriterionOuterEnvelopeSchema = effect_1.Schema.Union(exports.BuiltInCrit
 const ValueMatchCriterionSchema = effect_1.Schema.Struct({
     kind: effect_1.Schema.Literal("builtin"),
     id: effect_1.Schema.Literal("value-match/v1"),
-    data: effect_1.Schema.Struct({ subject: effect_1.Schema.Literal("explicit-value") }),
+    data: effect_1.Schema.Struct({
+        subject: effect_1.Schema.Literal("explicit-value"),
+        matcher: effect_1.Schema.Union(effect_1.Schema.Struct({ state: effect_1.Schema.Literal("declared"), name: BoundedJsonStringSchema }), effect_1.Schema.Struct({ state: effect_1.Schema.Literal("unavailable") })),
+    }),
 });
 const ScopeStatusCriterionSchema = effect_1.Schema.Struct({
     kind: effect_1.Schema.Literal("builtin"),
@@ -398,35 +401,67 @@ const UnavailableScoreContributionSchema = effect_1.Schema.Struct({
     points: NonNegativeNumberSchema,
     reason: effect_1.Schema.Literal("source-unavailable", "evaluation-errored", "not-applicable"),
 });
+const AssertionCollectionReceiptSchema = effect_1.Schema.Struct({
+    examined: NonNegativeIntegerSchema,
+    matched: NonNegativeIntegerSchema,
+    mismatched: NonNegativeIntegerSchema,
+    unavailable: NonNegativeIntegerSchema,
+    knownTotal: effect_1.Schema.NullOr(NonNegativeIntegerSchema),
+    complete: effect_1.Schema.Boolean,
+    exhaustive: effect_1.Schema.Boolean,
+    decisive: effect_1.Schema.Boolean,
+});
+const AssertionFactValueSchema = effect_1.Schema.suspend(() => effect_1.Schema.Union(effect_1.Schema.Struct({
+    kind: effect_1.Schema.Literal("unavailable"),
+    reason: effect_1.Schema.Literal("not-recorded", "not-declared", "source-unavailable"),
+}), effect_1.Schema.Struct({ kind: effect_1.Schema.Literal("value"), value: effect_1.Schema.Union(effect_1.Schema.Null, effect_1.Schema.Boolean, effect_1.Schema.JsonNumber, BoundedJsonStringSchema) }), effect_1.Schema.Struct({ kind: effect_1.Schema.Literal("text"), text: BoundedJsonStringSchema }), effect_1.Schema.Struct({ kind: effect_1.Schema.Literal("list"), items: effect_1.Schema.Array(AssertionFactValueSchema) }), effect_1.Schema.Struct({
+    kind: effect_1.Schema.Literal("fields"),
+    fields: effect_1.Schema.Array(effect_1.Schema.Struct({ label: BoundedJsonStringSchema, value: AssertionFactValueSchema })),
+})));
+const AssertionDecisionPolicySchema = effect_1.Schema.Struct({
+    requirement: effect_1.Schema.Union(effect_1.Schema.Struct({
+        state: effect_1.Schema.Literal("available"),
+        value: effect_1.Schema.Literal("required", "optional"),
+    }), effect_1.Schema.Struct({ state: effect_1.Schema.Literal("unavailable"), reason: effect_1.Schema.Literal("not-recorded") })),
+    condition: effect_1.Schema.Union(effect_1.Schema.Struct({
+        state: effect_1.Schema.Literal("available"),
+        value: effect_1.Schema.Union(effect_1.Schema.Struct({ kind: effect_1.Schema.Literal("boolean"), expected: effect_1.Schema.Literal(true) }), effect_1.Schema.Struct({ kind: effect_1.Schema.Literal("at-least"), threshold: NonNegativeNumberSchema }), effect_1.Schema.Struct({ kind: effect_1.Schema.Literal("record-only") })),
+    }), effect_1.Schema.Struct({ state: effect_1.Schema.Literal("unavailable"), reason: effect_1.Schema.Literal("not-recorded") })),
+});
 exports.SealedAssertionResultSchema = effect_1.Schema.Union(effect_1.Schema.Struct({
     state: effect_1.Schema.Literal("matched"),
     gate: effect_1.Schema.Literal("not-gate", "satisfied"),
     score: effect_1.Schema.Union(NoScoreContributionSchema, EarnedScoreContributionSchema),
     diagnostic: effect_1.Schema.optional(exports.BoundedJsonObjectSchema),
+    receipt: effect_1.Schema.optional(AssertionCollectionReceiptSchema),
 }), effect_1.Schema.Struct({
     state: effect_1.Schema.Literal("mismatched"),
     reason: effect_1.Schema.Literal("condition-not-met"),
     gate: effect_1.Schema.Literal("not-gate", "failed"),
     score: effect_1.Schema.Union(NoScoreContributionSchema, EarnedScoreContributionSchema),
     diagnostic: effect_1.Schema.optional(exports.BoundedJsonObjectSchema),
+    receipt: effect_1.Schema.optional(AssertionCollectionReceiptSchema),
 }), effect_1.Schema.Struct({
     state: effect_1.Schema.Literal("unavailable"),
     reason: effect_1.Schema.Literal("evidence-unavailable", "source-unavailable", "redacted"),
     gate: effect_1.Schema.Literal("not-gate", "unavailable"),
     score: effect_1.Schema.Union(NoScoreContributionSchema, UnavailableScoreContributionSchema),
     diagnostic: effect_1.Schema.optional(exports.BoundedJsonObjectSchema),
+    receipt: effect_1.Schema.optional(AssertionCollectionReceiptSchema),
 }), effect_1.Schema.Struct({
     state: effect_1.Schema.Literal("errored"),
     reason: effect_1.Schema.Literal("evaluator-failed", "producer-interrupted", "invalid-subject"),
     gate: effect_1.Schema.Literal("not-gate", "unavailable"),
     score: effect_1.Schema.Union(NoScoreContributionSchema, UnavailableScoreContributionSchema),
     diagnostic: effect_1.Schema.optional(exports.BoundedJsonObjectSchema),
+    receipt: effect_1.Schema.optional(AssertionCollectionReceiptSchema),
 }), effect_1.Schema.Struct({
     state: effect_1.Schema.Literal("not-applicable"),
     reason: effect_1.Schema.Literal("coverage-not-applicable"),
     gate: effect_1.Schema.Literal("not-gate", "not-applicable"),
     score: effect_1.Schema.Union(NoScoreContributionSchema, UnavailableScoreContributionSchema),
     diagnostic: effect_1.Schema.optional(exports.BoundedJsonObjectSchema),
+    receipt: effect_1.Schema.optional(AssertionCollectionReceiptSchema),
 }));
 /**
  * Record owns the opaque blob-ref codec.  Assertions owns only its shape and
@@ -435,6 +470,9 @@ exports.SealedAssertionResultSchema = effect_1.Schema.Union(effect_1.Schema.Stru
  */
 function createAssertionsRecordSchemas(blobRefSchema) {
     const material = effect_1.Schema.Union(effect_1.Schema.Struct({
+        kind: effect_1.Schema.Literal("unavailable"),
+        reason: effect_1.Schema.Literal("not-recorded"),
+    }), effect_1.Schema.Struct({
         kind: effect_1.Schema.Literal("snapshot"),
         value: exports.BoundedJsonValueSchema,
     }), effect_1.Schema.Struct({
@@ -447,7 +485,7 @@ function createAssertionsRecordSchemas(blobRefSchema) {
     }));
     const evidence = effect_1.Schema.Array(material);
     const limitations = effect_1.Schema.Array(exports.AssertionLimitationSchema);
-    const outerEntry = effect_1.Schema.Struct({
+    const historicalOuterEntry = effect_1.Schema.Struct({
         entryId: exports.AssertionEntryIdSchema,
         display: exports.AssertionDisplaySchema,
         criterion: exports.BoundedJsonObjectSchema,
@@ -460,6 +498,40 @@ function createAssertionsRecordSchemas(blobRefSchema) {
         identifier: "AssertionCoverageLimitations",
         description: "coverage and limitations with a consistent sealed relationship",
     }));
+    const materials = effect_1.Schema.Struct({
+        source: material,
+        evidence,
+        coverage: exports.AssertionCoverageSchema,
+        limitations,
+    }).pipe(effect_1.Schema.filter((value) => hasCoverageConsistentLimitations(value), {
+        identifier: "AssertionCoverageLimitations",
+        description: "coverage and limitations with a consistent sealed relationship",
+    }));
+    const evaluation = effect_1.Schema.Struct({
+        observed: AssertionFactValueSchema,
+        receipt: effect_1.Schema.optional(AssertionCollectionReceiptSchema),
+    });
+    const decision = effect_1.Schema.Struct({
+        result: effect_1.Schema.Literal("matched", "mismatched", "unavailable", "errored", "not-applicable"),
+        reason: effect_1.Schema.NullOr(effect_1.Schema.Literal("condition-not-met", "evidence-unavailable", "source-unavailable", "redacted", "evaluator-failed", "producer-interrupted", "invalid-subject", "coverage-not-applicable")),
+        gate: effect_1.Schema.Literal("not-gate", "satisfied", "failed", "unavailable", "not-applicable"),
+    });
+    const explanationRetention = effect_1.Schema.Union(effect_1.Schema.Struct({ state: effect_1.Schema.Literal("retained"), value: AssertionFactValueSchema }), effect_1.Schema.Struct({ state: effect_1.Schema.Literal("unavailable"), reason: effect_1.Schema.Literal("not-recorded") }));
+    const outerEntry = effect_1.Schema.Struct({
+        entryId: exports.AssertionEntryIdSchema,
+        display: exports.AssertionDisplaySchema,
+        criterion: effect_1.Schema.Union(effect_1.Schema.Struct({ state: effect_1.Schema.Literal("available"), value: exports.BoundedJsonObjectSchema }), effect_1.Schema.Struct({ state: effect_1.Schema.Literal("unavailable"), reason: effect_1.Schema.Literal("not-recorded") })),
+        materials,
+        evaluation,
+        decision,
+        policy: AssertionDecisionPolicySchema,
+        contribution: effect_1.Schema.Union(NoScoreContributionSchema, EarnedScoreContributionSchema, UnavailableScoreContributionSchema),
+        explanationRetention,
+    });
+    const historicalEntries = effect_1.Schema.Array(historicalOuterEntry).pipe(effect_1.Schema.filter((values) => values.length <= limits_ts_1.assertionRuntimeLimits.entries, {
+        identifier: "AssertionsEntryCount",
+        description: "at most 4,096 assertion entries",
+    }));
     const entries = effect_1.Schema.Array(outerEntry).pipe(effect_1.Schema.filter((values) => values.length <= limits_ts_1.assertionRuntimeLimits.entries, {
         identifier: "AssertionsEntryCount",
         description: "at most 4,096 assertion entries",
@@ -474,16 +546,14 @@ function createAssertionsRecordSchemas(blobRefSchema) {
     const entry = effect_1.Schema.Struct({
         entryId: exports.AssertionEntryIdSchema,
         display: exports.AssertionDisplaySchema,
-        criterion: exports.CriterionEnvelopeSchema,
-        subject: material,
-        evidence,
-        coverage: exports.AssertionCoverageSchema,
-        limitations,
-        result: exports.SealedAssertionResultSchema,
-    }).pipe(effect_1.Schema.filter(hasCoverageConsistentLimitations, {
-        identifier: "AssertionCoverageLimitations",
-        description: "coverage and limitations with a consistent sealed relationship",
-    }));
+        criterion: effect_1.Schema.Union(effect_1.Schema.Struct({ state: effect_1.Schema.Literal("available"), value: exports.CriterionEnvelopeSchema }), effect_1.Schema.Struct({ state: effect_1.Schema.Literal("unavailable"), reason: effect_1.Schema.Literal("not-recorded") })),
+        materials,
+        evaluation,
+        decision,
+        policy: AssertionDecisionPolicySchema,
+        contribution: effect_1.Schema.Union(NoScoreContributionSchema, EarnedScoreContributionSchema, UnavailableScoreContributionSchema),
+        explanationRetention,
+    });
     const document = effect_1.Schema.Struct({
         entries: effect_1.Schema.Array(entry).pipe(effect_1.Schema.filter((entries) => entries.length <= limits_ts_1.assertionRuntimeLimits.entries, {
             identifier: "AssertionsEntryCount",
@@ -496,7 +566,7 @@ function createAssertionsRecordSchemas(blobRefSchema) {
         identifier: "AssertionsDocumentSize",
         description: "a JSON document no larger than 4 MiB",
     }));
-    return Object.freeze({ material, entries, outerDocument, document });
+    return Object.freeze({ material, entries, historicalEntries, outerDocument, document });
 }
 const assertionsDocumentInvalid = Object.freeze({
     code: "assertions-document-invalid",
@@ -557,14 +627,18 @@ const KNOWN_BUILTIN_CRITERION_IDS = new Set([
 function availableEntry(entry, criterion) {
     const available = {
         ...entry,
-        criterion,
+        criterion: Object.freeze({ state: "available", value: criterion }),
     };
     return Object.freeze({ state: "available", entry: Object.freeze(available) });
 }
 function projectAssertionEntry(entry, registry) {
-    const builtinEnvelope = effect_1.Schema.decodeUnknownEither(exports.BuiltInCriterionEnvelopeSchema, exports.AssertionsExactParseOptions)(entry.criterion);
+    if (entry.criterion.state === "unavailable") {
+        return Object.freeze({ state: "available", entry: entry });
+    }
+    const criterionValue = entry.criterion.value;
+    const builtinEnvelope = effect_1.Schema.decodeUnknownEither(exports.BuiltInCriterionEnvelopeSchema, exports.AssertionsExactParseOptions)(criterionValue);
     if (effect_1.Either.isRight(builtinEnvelope)) {
-        const builtin = effect_1.Schema.decodeUnknownEither(exports.BuiltInCriterionSchema, exports.AssertionsExactParseOptions)(entry.criterion);
+        const builtin = effect_1.Schema.decodeUnknownEither(exports.BuiltInCriterionSchema, exports.AssertionsExactParseOptions)(criterionValue);
         if (effect_1.Either.isRight(builtin)) {
             return availableEntry(entry, builtin.right);
         }
@@ -581,7 +655,7 @@ function projectAssertionEntry(entry, registry) {
             reason: "builtin-unknown",
         });
     }
-    const thirdParty = effect_1.Schema.decodeUnknownEither(exports.ThirdPartyCriterionSchema, exports.AssertionsExactParseOptions)(entry.criterion);
+    const thirdParty = effect_1.Schema.decodeUnknownEither(exports.ThirdPartyCriterionSchema, exports.AssertionsExactParseOptions)(criterionValue);
     if (effect_1.Either.isLeft(thirdParty)) {
         return Object.freeze({
             state: "invalid",