niceeval 0.13.2 → 0.13.3

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

@@ -1,5 +1,5 @@
 import { Either, Schema } from "effect";
-import { type AssertionCoverage, type AssertionDisplay, type AssertionEntryId, type AssertionLimitation, type AssertionsDocumentOuter, type AssertionsDocument, type AssertionsProjection, type BoundedJsonObject, type BoundedJsonValue, type BuiltInCriterionEnvelope, type BuiltInCriterion, type CriterionOuterEnvelope, type SealedAssertionResult, type ThirdPartyCriterion, type WritableCriterionEnvelope } from "./model.js";
+import { type AssertionCoverage, type AssertionDisplay, type AssertionFactValue, type AssertionEntryId, type AssertionLimitation, type AssertionsDocumentOuter, type AssertionsDocument, type AssertionsProjection, type BoundedJsonObject, type BoundedJsonValue, type BuiltInCriterionEnvelope, type BuiltInCriterion, type CriterionOuterEnvelope, type EarnedScoreContribution, type NoScoreContribution, type SealedAssertionResult, type ThirdPartyCriterion, type UnavailableScoreContribution, type WritableCriterionEnvelope } from "./model.js";
 /** Durable document-size limit; unlike runtime capture limits it belongs to this codec. */
 export declare const MAX_ASSERTION_DOCUMENT_BYTES: number;
 /** All contract-owned objects use aggregate failures and exact object fields. */
@@ -30,6 +30,9 @@ export declare const SealedAssertionResultSchema: Schema.Schema<SealedAssertionR
  */
 export declare function createAssertionsRecordSchemas<BlobRef, BlobRefEncoded>(blobRefSchema: Schema.Schema<BlobRef, BlobRefEncoded>): 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<{
@@ -40,11 +43,107 @@ export declare function createAssertionsRecordSchemas<BlobRef, BlobRefEncoded>(b
         sha256: Schema.Schema<import("../../record/model/identifiers.js").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<AssertionDisplay, 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<BlobRef, BlobRefEncoded, never>;
+                encoding: Schema.Literal<["utf-8", "binary"]>;
+                byteLength: Schema.filter<typeof Schema.JsonNumber>;
+                sha256: Schema.Schema<import("../../record/model/identifiers.js").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<BlobRef, BlobRefEncoded, never>;
+                encoding: Schema.Literal<["utf-8", "binary"]>;
+                byteLength: Schema.filter<typeof Schema.JsonNumber>;
+                sha256: Schema.Schema<import("../../record/model/identifiers.js").Sha256Digest, string, never>;
+                preview: Schema.filter<typeof Schema.String>;
+            }>]>>;
+            coverage: Schema.Schema<AssertionCoverage, AssertionCoverage, never>;
+            limitations: Schema.Array$<Schema.Schema<AssertionLimitation, AssertionLimitation, 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<NoScoreContribution, NoScoreContribution, never>, Schema.Schema<EarnedScoreContribution, EarnedScoreContribution, never>, Schema.Schema<UnavailableScoreContribution, 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<AssertionDisplay, 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<{
@@ -56,6 +155,9 @@ export declare function createAssertionsRecordSchemas<BlobRef, BlobRefEncoded>(b
             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<{
@@ -71,68 +173,194 @@ export declare function createAssertionsRecordSchemas<BlobRef, BlobRefEncoded>(b
         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<AssertionDisplay, 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<BlobRef, BlobRefEncoded, never>;
-                encoding: Schema.Literal<["utf-8", "binary"]>;
-                byteLength: Schema.filter<typeof Schema.JsonNumber>;
-                sha256: Schema.Schema<import("../../record/model/identifiers.js").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<BlobRef, BlobRefEncoded, never>;
+                    encoding: Schema.Literal<["utf-8", "binary"]>;
+                    byteLength: Schema.filter<typeof Schema.JsonNumber>;
+                    sha256: Schema.Schema<import("../../record/model/identifiers.js").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<BlobRef, BlobRefEncoded, never>;
+                    encoding: Schema.Literal<["utf-8", "binary"]>;
+                    byteLength: Schema.filter<typeof Schema.JsonNumber>;
+                    sha256: Schema.Schema<import("../../record/model/identifiers.js").Sha256Digest, string, never>;
+                    preview: Schema.filter<typeof Schema.String>;
+                }>]>>;
+                coverage: Schema.Schema<AssertionCoverage, AssertionCoverage, never>;
+                limitations: Schema.Array$<Schema.Schema<AssertionLimitation, AssertionLimitation, 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<NoScoreContribution, NoScoreContribution, never>, Schema.Schema<EarnedScoreContribution, EarnedScoreContribution, never>, Schema.Schema<UnavailableScoreContribution, 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<BlobRef, BlobRefEncoded, never>;
-                encoding: Schema.Literal<["utf-8", "binary"]>;
-                byteLength: Schema.filter<typeof Schema.JsonNumber>;
-                sha256: Schema.Schema<import("../../record/model/identifiers.js").Sha256Digest, string, never>;
-                preview: Schema.filter<typeof Schema.String>;
-            }>]>>;
-            coverage: Schema.Schema<AssertionCoverage, AssertionCoverage, never>;
-            limitations: Schema.Array$<Schema.Schema<AssertionLimitation, AssertionLimitation, 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<AssertionDisplay, 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<BlobRef, BlobRefEncoded, never>;
-                encoding: Schema.Literal<["utf-8", "binary"]>;
-                byteLength: Schema.filter<typeof Schema.JsonNumber>;
-                sha256: Schema.Schema<import("../../record/model/identifiers.js").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<BlobRef, BlobRefEncoded, never>;
+                    encoding: Schema.Literal<["utf-8", "binary"]>;
+                    byteLength: Schema.filter<typeof Schema.JsonNumber>;
+                    sha256: Schema.Schema<import("../../record/model/identifiers.js").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<BlobRef, BlobRefEncoded, never>;
+                    encoding: Schema.Literal<["utf-8", "binary"]>;
+                    byteLength: Schema.filter<typeof Schema.JsonNumber>;
+                    sha256: Schema.Schema<import("../../record/model/identifiers.js").Sha256Digest, string, never>;
+                    preview: Schema.filter<typeof Schema.String>;
+                }>]>>;
+                coverage: Schema.Schema<AssertionCoverage, AssertionCoverage, never>;
+                limitations: Schema.Array$<Schema.Schema<AssertionLimitation, AssertionLimitation, 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<NoScoreContribution, NoScoreContribution, never>, Schema.Schema<EarnedScoreContribution, EarnedScoreContribution, never>, Schema.Schema<UnavailableScoreContribution, 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<BlobRef, BlobRefEncoded, never>;
-                encoding: Schema.Literal<["utf-8", "binary"]>;
-                byteLength: Schema.filter<typeof Schema.JsonNumber>;
-                sha256: Schema.Schema<import("../../record/model/identifiers.js").Sha256Digest, string, never>;
-                preview: Schema.filter<typeof Schema.String>;
-            }>]>>;
-            coverage: Schema.Schema<AssertionCoverage, AssertionCoverage, never>;
-            limitations: Schema.Array$<Schema.Schema<AssertionLimitation, AssertionLimitation, never>>;
-            result: Schema.Schema<SealedAssertionResult, SealedAssertionResult, never>;
-        }>>>>;
+                state: Schema.Literal<["unavailable"]>;
+                reason: Schema.Literal<["not-recorded"]>;
+            }>]>;
+        }>>>;
     }>>>;
 }>;
 export interface AssertionsRecordCodecError {

package/dist/assertions/record/index.js

@@ -71,4 +71,6 @@ const __niceevalExport33 = __niceevalCanonical["projectAssertionsDocument"];
 export { __niceevalExport33 as projectAssertionsDocument };
 const __niceevalExport34 = __niceevalCanonical["projectFileChangesAttachment"];
 export { __niceevalExport34 as projectFileChangesAttachment };
+const __niceevalExport35 = __niceevalCanonical["sealedAssertionResult"];
+export { __niceevalExport35 as sealedAssertionResult };
 //# sourceMappingURL=index.js.map

package/dist/assertions/record/model.cjs

@@ -1,10 +1,26 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ASSERTION_ENTRY_ID_BRAND = void 0;
+exports.sealedAssertionResult = sealedAssertionResult;
 /**
  * `entryId` is only stable inside one Assertions Attachment. It is not an
  * authoring key and deliberately has no cross-Attempt meaning.
  */
 var identity_ts_1 = require("../identity.cjs");
 Object.defineProperty(exports, "ASSERTION_ENTRY_ID_BRAND", { enumerable: true, get: function () { return identity_ts_1.ASSERTION_ENTRY_ID_BRAND; } });
+function sealedAssertionResult(entry) {
+    const receipt = entry.evaluation.receipt === undefined ? {} : { receipt: entry.evaluation.receipt };
+    switch (entry.decision.result) {
+        case "matched":
+            return Object.freeze({ state: "matched", gate: entry.decision.gate, score: entry.contribution, ...receipt });
+        case "mismatched":
+            return Object.freeze({ state: "mismatched", reason: "condition-not-met", gate: entry.decision.gate, score: entry.contribution, ...receipt });
+        case "unavailable":
+            return Object.freeze({ state: "unavailable", reason: entry.decision.reason, gate: entry.decision.gate, score: entry.contribution, ...receipt });
+        case "errored":
+            return Object.freeze({ state: "errored", reason: entry.decision.reason, gate: entry.decision.gate, score: entry.contribution, ...receipt });
+        case "not-applicable":
+            return Object.freeze({ state: "not-applicable", reason: "coverage-not-applicable", gate: entry.decision.gate, score: entry.contribution, ...receipt });
+    }
+}
 //# sourceMappingURL=model.cjs.map

package/dist/assertions/record/model.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"model.js","sourceRoot":"","sources":["model.ts"],"names":[],"mappings":";;;AAEA;;;GAGG;AACH,8CAA2D;AAAlD,uHAAA,wBAAwB,OAAA","sourcesContent":["import type { AssertionEntryId } from \"../identity.ts\";\nimport type { Sha256Digest } from \"../../record/model/identifiers.ts\";\n/**\n * `entryId` is only stable inside one Assertions Attachment. It is not an\n * authoring key and deliberately has no cross-Attempt meaning.\n */\nexport { ASSERTION_ENTRY_ID_BRAND, } from \"../identity.ts\";\nexport type { AssertionEntryId } from \"../identity.ts\";\nexport type BoundedJsonPrimitive = null | boolean | number | string;\nexport interface BoundedJsonObject {\n    readonly [key: string]: BoundedJsonValue;\n}\n/** JSON-only material that is bounded by the Assertions v1 decoder. */\nexport type BoundedJsonValue = BoundedJsonPrimitive | readonly BoundedJsonValue[] | BoundedJsonObject;\nexport interface AssertionDisplay {\n    readonly key?: string;\n    readonly label?: string;\n    readonly groupPath: readonly string[];\n}\n/** The outer builtin shape deliberately preserves an unknown future id. */\nexport interface BuiltInCriterionEnvelope {\n    readonly kind: \"builtin\";\n    readonly id: string;\n    readonly data: BoundedJsonValue;\n}\n/** Third-party data is exact JSON owned by the named third-party schema. */\nexport interface ThirdPartyCriterion {\n    readonly name: string;\n    readonly schemaId: string;\n    readonly data: BoundedJsonValue;\n}\n/** Raw identity envelope used by the reader's second decode phase. */\nexport type CriterionEnvelope = BuiltInCriterionEnvelope | ThirdPartyCriterion;\nexport type CriterionOuterEnvelope = CriterionEnvelope;\nexport type BuiltInCriterion = {\n    readonly kind: \"builtin\";\n    readonly id: \"value-match/v1\";\n    readonly data: {\n        readonly subject: \"explicit-value\";\n    };\n} | {\n    readonly kind: \"builtin\";\n    readonly id: \"scope-status/v1\";\n    readonly data: {\n        readonly scope: \"turn\" | \"session\" | \"attempt\";\n        readonly assertion: \"succeeded\" | \"no-failed-actions\";\n    };\n} | {\n    readonly kind: \"builtin\";\n    readonly id: \"occurrence/v1\";\n    readonly data: {\n        readonly scope: \"turn\" | \"session\" | \"attempt\";\n        readonly occurrence: \"tool\" | \"skill\" | \"event\";\n        readonly assertion: \"present\" | \"absent\" | \"count\";\n        /** Tool assertions retain the single managed matcher identity. */\n        readonly matcher?: string;\n        readonly quantifier?: {\n            readonly kind: \"absent\";\n        } | {\n            readonly kind: \"at-least\" | \"exact\";\n            readonly count: number;\n        };\n    };\n} | {\n    readonly kind: \"builtin\";\n    readonly id: \"judge-measurement/v1\";\n    readonly data: {\n        readonly recipe: \"closed-qa\" | \"factuality\" | \"summarizes\";\n        readonly scale: \"unit-interval\";\n    };\n} | {\n    readonly kind: \"builtin\";\n    readonly id: \"sandbox-result/v1\";\n    readonly data: {\n        readonly operation: \"changed-paths\";\n        readonly paths: readonly string[];\n    };\n} | {\n    readonly kind: \"builtin\";\n    readonly id: \"sandbox-result/v1\";\n    readonly data: {\n        readonly operation: \"no-changes\";\n    };\n} | {\n    readonly kind: \"builtin\";\n    readonly id: \"sandbox-result/v1\";\n    readonly data: {\n        readonly operation: \"file-changed\";\n        readonly path: string;\n        readonly status?: \"added\" | \"modified\" | \"deleted\";\n        /** Persisted display identity only; evaluators retain the managed Match. */\n        readonly before?: string;\n        readonly after?: string;\n    };\n} | {\n    readonly kind: \"builtin\";\n    readonly id: \"sandbox-result/v1\";\n    readonly data: {\n        readonly operation: \"file-deleted\";\n        readonly path: string;\n    };\n} | {\n    readonly kind: \"builtin\";\n    readonly id: \"sandbox-result/v1\";\n    readonly data: {\n        readonly operation: \"not-in-diff\";\n        readonly pattern: string;\n        readonly flags: string;\n        readonly content: \"added\" | \"removed\" | \"both\";\n    };\n} | {\n    readonly kind: \"builtin\";\n    readonly id: \"direct-score/v1\";\n    readonly data: {\n        readonly source: \"author\";\n    };\n};\n/** A v1 writer may only emit a known builtin or a versioned third-party schema. */\nexport type WritableCriterionEnvelope = BuiltInCriterion | ThirdPartyCriterion;\nexport type AssertionMaterial<BlobRef> = {\n    readonly kind: \"snapshot\";\n    readonly value: BoundedJsonValue;\n} | {\n    readonly kind: \"blob\";\n    readonly ref: BlobRef;\n    readonly encoding: \"utf-8\" | \"binary\";\n    readonly byteLength: number;\n    /** SHA-256 of the exact retained blob bytes. */\n    readonly sha256: Sha256Digest;\n    readonly preview: string;\n};\nexport type AssertionCoverage = {\n    readonly state: \"complete\";\n} | {\n    readonly state: \"partial\";\n    readonly reason: \"sampled\" | \"truncated\" | \"redacted\" | \"provider-limited\";\n} | {\n    readonly state: \"unavailable\";\n    readonly reason: \"not-collected\" | \"source-unavailable\" | \"producer-failed\";\n} | {\n    readonly state: \"not-applicable\";\n    readonly reason: \"optional-material\" | \"unsupported-subject\";\n};\nexport type AssertionLimitation = {\n    readonly kind: \"redacted\";\n    readonly fieldCount: number;\n} | {\n    readonly kind: \"sampled\";\n    readonly captured: number;\n    readonly knownTotal?: number;\n} | {\n    readonly kind: \"truncated\";\n    readonly omittedBytes: number;\n} | {\n    readonly kind: \"provider-limited\";\n};\nexport type GateDisposition = \"not-gate\" | \"satisfied\" | \"failed\" | \"unavailable\" | \"not-applicable\";\nexport interface NoScoreContribution {\n    readonly state: \"not-scored\";\n}\nexport interface EarnedScoreContribution {\n    readonly state: \"earned\";\n    readonly points: number;\n    readonly earned: number;\n}\nexport interface UnavailableScoreContribution {\n    readonly state: \"unavailable\";\n    readonly points: number;\n    readonly reason: \"source-unavailable\" | \"evaluation-errored\" | \"not-applicable\";\n}\nexport type ScoreContribution = NoScoreContribution | EarnedScoreContribution | UnavailableScoreContribution;\nexport type SealedAssertionResult = {\n    readonly state: \"matched\";\n    readonly gate: \"not-gate\" | \"satisfied\";\n    readonly score: NoScoreContribution | EarnedScoreContribution;\n    /** Bounded evaluator diagnostics, including ToolMatch evidence paths. */\n    readonly diagnostic?: BoundedJsonObject;\n} | {\n    readonly state: \"mismatched\";\n    readonly reason: \"condition-not-met\";\n    readonly gate: \"not-gate\" | \"failed\";\n    readonly score: NoScoreContribution | EarnedScoreContribution;\n    readonly diagnostic?: BoundedJsonObject;\n} | {\n    readonly state: \"unavailable\";\n    readonly reason: \"evidence-unavailable\" | \"source-unavailable\" | \"redacted\";\n    readonly gate: \"not-gate\" | \"unavailable\";\n    readonly score: NoScoreContribution | UnavailableScoreContribution;\n    readonly diagnostic?: BoundedJsonObject;\n} | {\n    readonly state: \"errored\";\n    readonly reason: \"evaluator-failed\" | \"producer-interrupted\" | \"invalid-subject\";\n    readonly gate: \"not-gate\" | \"unavailable\";\n    readonly score: NoScoreContribution | UnavailableScoreContribution;\n    readonly diagnostic?: BoundedJsonObject;\n} | {\n    readonly state: \"not-applicable\";\n    readonly reason: \"coverage-not-applicable\";\n    readonly gate: \"not-gate\" | \"not-applicable\";\n    readonly score: NoScoreContribution | UnavailableScoreContribution;\n    readonly diagnostic?: BoundedJsonObject;\n};\n/** The exact v1 value that a producer is allowed to seal. */\nexport interface AssertionEntry<BlobRef> {\n    readonly entryId: AssertionEntryId;\n    readonly display: AssertionDisplay;\n    readonly criterion: WritableCriterionEnvelope;\n    readonly subject: AssertionMaterial<BlobRef>;\n    readonly evidence: readonly AssertionMaterial<BlobRef>[];\n    readonly coverage: AssertionCoverage;\n    readonly limitations: readonly AssertionLimitation[];\n    readonly result: SealedAssertionResult;\n}\n/**\n * Reader framing intentionally leaves `criterion` as bounded JSON.  This\n * lets a bad plugin or future criterion affect its entry only after every\n * other entry boundary has already been verified.\n */\nexport interface AssertionEntryOuter<BlobRef> {\n    readonly entryId: AssertionEntryId;\n    readonly display: AssertionDisplay;\n    readonly criterion: BoundedJsonObject;\n    readonly subject: AssertionMaterial<BlobRef>;\n    readonly evidence: readonly AssertionMaterial<BlobRef>[];\n    readonly coverage: AssertionCoverage;\n    readonly limitations: readonly AssertionLimitation[];\n    readonly result: SealedAssertionResult;\n}\nexport interface AssertionsDocument<BlobRef> {\n    readonly entries: readonly AssertionEntry<BlobRef>[];\n}\nexport interface AssertionsDocumentOuter<BlobRef> {\n    readonly entries: readonly AssertionEntryOuter<BlobRef>[];\n}\nexport type AssertionEntryRead<BlobRef> = {\n    readonly state: \"available\";\n    readonly entry: AssertionEntry<BlobRef>;\n} | {\n    readonly state: \"unsupported\";\n    readonly entry: AssertionEntryOuter<BlobRef>;\n    readonly reason: \"builtin-unknown\" | \"third-party-schema-unavailable\";\n} | {\n    readonly state: \"invalid\";\n    readonly entry: AssertionEntryOuter<BlobRef>;\n    readonly reason: \"criterion-envelope-invalid\" | \"criterion-data-invalid\";\n};\nexport interface AssertionsProjection<BlobRef> {\n    readonly entries: readonly AssertionEntryRead<BlobRef>[];\n}\n"]}
+{"version":3,"file":"model.js","sourceRoot":"","sources":["model.ts"],"names":[],"mappings":";;;AA2SA,sDAcC;AAvTD;;;GAGG;AACH,8CAA2D;AAAlD,uHAAA,wBAAwB,OAAA;AAqSjC,SAAgB,qBAAqB,CAAC,KAAgF;IAClH,MAAM,OAAO,GAAG,KAAK,CAAC,UAAU,CAAC,OAAO,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,KAAK,CAAC,UAAU,CAAC,OAAO,EAAE,CAAC;IACpG,QAAQ,KAAK,CAAC,QAAQ,CAAC,MAAM,EAAE,CAAC;QAC5B,KAAK,SAAS;YACV,OAAO,MAAM,CAAC,MAAM,CAAC,EAAE,KAAK,EAAE,SAAS,EAAE,IAAI,EAAE,KAAK,CAAC,QAAQ,CAAC,IAAgC,EAAE,KAAK,EAAE,KAAK,CAAC,YAA6D,EAAE,GAAG,OAAO,EAAE,CAAC,CAAC;QAC9L,KAAK,YAAY;YACb,OAAO,MAAM,CAAC,MAAM,CAAC,EAAE,KAAK,EAAE,YAAY,EAAE,MAAM,EAAE,mBAAmB,EAAE,IAAI,EAAE,KAAK,CAAC,QAAQ,CAAC,IAA6B,EAAE,KAAK,EAAE,KAAK,CAAC,YAA6D,EAAE,GAAG,OAAO,EAAE,CAAC,CAAC;QAC3N,KAAK,aAAa;YACd,OAAO,MAAM,CAAC,MAAM,CAAC,EAAE,KAAK,EAAE,aAAa,EAAE,MAAM,EAAE,KAAK,CAAC,QAAQ,CAAC,MAAoE,EAAE,IAAI,EAAE,KAAK,CAAC,QAAQ,CAAC,IAAkC,EAAE,KAAK,EAAE,KAAK,CAAC,YAAkE,EAAE,GAAG,OAAO,EAAE,CAAC,CAAC;QACtS,KAAK,SAAS;YACV,OAAO,MAAM,CAAC,MAAM,CAAC,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,EAAE,KAAK,CAAC,QAAQ,CAAC,MAAyE,EAAE,IAAI,EAAE,KAAK,CAAC,QAAQ,CAAC,IAAkC,EAAE,KAAK,EAAE,KAAK,CAAC,YAAkE,EAAE,GAAG,OAAO,EAAE,CAAC,CAAC;QACvS,KAAK,gBAAgB;YACjB,OAAO,MAAM,CAAC,MAAM,CAAC,EAAE,KAAK,EAAE,gBAAgB,EAAE,MAAM,EAAE,yBAAyB,EAAE,IAAI,EAAE,KAAK,CAAC,QAAQ,CAAC,IAAqC,EAAE,KAAK,EAAE,KAAK,CAAC,YAAkE,EAAE,GAAG,OAAO,EAAE,CAAC,CAAC;IACtP,CAAC;AACL,CAAC","sourcesContent":["import type { AssertionEntryId } from \"../identity.ts\";\nimport type { Sha256Digest } from \"../../record/model/identifiers.ts\";\n/**\n * `entryId` is only stable inside one Assertions Attachment. It is not an\n * authoring key and deliberately has no cross-Attempt meaning.\n */\nexport { ASSERTION_ENTRY_ID_BRAND, } from \"../identity.ts\";\nexport type { AssertionEntryId } from \"../identity.ts\";\nexport type BoundedJsonPrimitive = null | boolean | number | string;\nexport interface BoundedJsonObject {\n    readonly [key: string]: BoundedJsonValue;\n}\n/** JSON-only material that is bounded by the Assertions v1 decoder. */\nexport type BoundedJsonValue = BoundedJsonPrimitive | readonly BoundedJsonValue[] | BoundedJsonObject;\nexport interface AssertionDisplay {\n    readonly key?: string;\n    readonly label?: string;\n    readonly groupPath: readonly string[];\n}\nexport type AssertionFactValue = {\n    readonly kind: \"unavailable\";\n    readonly reason: \"not-recorded\" | \"not-declared\" | \"source-unavailable\";\n} | {\n    readonly kind: \"value\";\n    readonly value: BoundedJsonPrimitive;\n} | {\n    readonly kind: \"text\";\n    readonly text: string;\n} | {\n    readonly kind: \"list\";\n    readonly items: readonly AssertionFactValue[];\n} | {\n    readonly kind: \"fields\";\n    readonly fields: readonly AssertionFactField[];\n};\nexport interface AssertionFactField {\n    readonly label: string;\n    readonly value: AssertionFactValue;\n}\nexport interface AssertionDecisionPolicy {\n    readonly requirement: {\n        readonly state: \"available\";\n        readonly value: \"required\" | \"optional\";\n    } | {\n        readonly state: \"unavailable\";\n        readonly reason: \"not-recorded\";\n    };\n    readonly condition: {\n        readonly state: \"available\";\n        readonly value: {\n            readonly kind: \"boolean\";\n            readonly expected: true;\n        } | {\n            readonly kind: \"at-least\";\n            readonly threshold: number;\n        } | {\n            readonly kind: \"record-only\";\n        };\n    } | {\n        readonly state: \"unavailable\";\n        readonly reason: \"not-recorded\";\n    };\n}\n/** The outer builtin shape deliberately preserves an unknown future id. */\nexport interface BuiltInCriterionEnvelope {\n    readonly kind: \"builtin\";\n    readonly id: string;\n    readonly data: BoundedJsonValue;\n}\n/** Third-party data is exact JSON owned by the named third-party schema. */\nexport interface ThirdPartyCriterion {\n    readonly name: string;\n    readonly schemaId: string;\n    readonly data: BoundedJsonValue;\n}\n/** Raw identity envelope used by the reader's second decode phase. */\nexport type CriterionEnvelope = BuiltInCriterionEnvelope | ThirdPartyCriterion;\nexport type CriterionOuterEnvelope = CriterionEnvelope;\nexport type BuiltInCriterion = {\n    readonly kind: \"builtin\";\n    readonly id: \"value-match/v1\";\n    readonly data: {\n        readonly subject: \"explicit-value\";\n        readonly matcher: {\n            readonly state: \"declared\";\n            readonly name: string;\n        } | {\n            readonly state: \"unavailable\";\n        };\n    };\n} | {\n    readonly kind: \"builtin\";\n    readonly id: \"scope-status/v1\";\n    readonly data: {\n        readonly scope: \"turn\" | \"session\" | \"attempt\";\n        readonly assertion: \"succeeded\" | \"no-failed-actions\";\n    };\n} | {\n    readonly kind: \"builtin\";\n    readonly id: \"occurrence/v1\";\n    readonly data: {\n        readonly scope: \"turn\" | \"session\" | \"attempt\";\n        readonly occurrence: \"tool\" | \"skill\" | \"event\";\n        readonly assertion: \"present\" | \"absent\" | \"count\";\n        /** Tool assertions retain the single managed matcher identity. */\n        readonly matcher?: string;\n        readonly quantifier?: {\n            readonly kind: \"absent\";\n        } | {\n            readonly kind: \"at-least\" | \"exact\";\n            readonly count: number;\n        };\n    };\n} | {\n    readonly kind: \"builtin\";\n    readonly id: \"judge-measurement/v1\";\n    readonly data: {\n        readonly recipe: \"closed-qa\" | \"factuality\" | \"summarizes\";\n        readonly scale: \"unit-interval\";\n    };\n} | {\n    readonly kind: \"builtin\";\n    readonly id: \"sandbox-result/v1\";\n    readonly data: {\n        readonly operation: \"changed-paths\";\n        readonly paths: readonly string[];\n    };\n} | {\n    readonly kind: \"builtin\";\n    readonly id: \"sandbox-result/v1\";\n    readonly data: {\n        readonly operation: \"no-changes\";\n    };\n} | {\n    readonly kind: \"builtin\";\n    readonly id: \"sandbox-result/v1\";\n    readonly data: {\n        readonly operation: \"file-changed\";\n        readonly path: string;\n        readonly status?: \"added\" | \"modified\" | \"deleted\";\n        /** Persisted display identity only; evaluators retain the managed Match. */\n        readonly before?: string;\n        readonly after?: string;\n    };\n} | {\n    readonly kind: \"builtin\";\n    readonly id: \"sandbox-result/v1\";\n    readonly data: {\n        readonly operation: \"file-deleted\";\n        readonly path: string;\n    };\n} | {\n    readonly kind: \"builtin\";\n    readonly id: \"sandbox-result/v1\";\n    readonly data: {\n        readonly operation: \"not-in-diff\";\n        readonly pattern: string;\n        readonly flags: string;\n        readonly content: \"added\" | \"removed\" | \"both\";\n    };\n} | {\n    readonly kind: \"builtin\";\n    readonly id: \"direct-score/v1\";\n    readonly data: {\n        readonly source: \"author\";\n    };\n};\n/** A v1 writer may only emit a known builtin or a versioned third-party schema. */\nexport type WritableCriterionEnvelope = BuiltInCriterion | ThirdPartyCriterion;\nexport type AssertionMaterial<BlobRef> = {\n    readonly kind: \"unavailable\";\n    readonly reason: \"not-recorded\";\n} | {\n    readonly kind: \"snapshot\";\n    readonly value: BoundedJsonValue;\n} | {\n    readonly kind: \"blob\";\n    readonly ref: BlobRef;\n    readonly encoding: \"utf-8\" | \"binary\";\n    readonly byteLength: number;\n    /** SHA-256 of the exact retained blob bytes. */\n    readonly sha256: Sha256Digest;\n    readonly preview: string;\n};\nexport type AssertionCoverage = {\n    readonly state: \"complete\";\n} | {\n    readonly state: \"partial\";\n    readonly reason: \"sampled\" | \"truncated\" | \"redacted\" | \"provider-limited\";\n} | {\n    readonly state: \"unavailable\";\n    readonly reason: \"not-collected\" | \"source-unavailable\" | \"producer-failed\";\n} | {\n    readonly state: \"not-applicable\";\n    readonly reason: \"optional-material\" | \"unsupported-subject\";\n};\nexport type AssertionLimitation = {\n    readonly kind: \"redacted\";\n    readonly fieldCount: number;\n} | {\n    readonly kind: \"sampled\";\n    readonly captured: number;\n    readonly knownTotal?: number;\n} | {\n    readonly kind: \"truncated\";\n    readonly omittedBytes: number;\n} | {\n    readonly kind: \"provider-limited\";\n};\nexport type GateDisposition = \"not-gate\" | \"satisfied\" | \"failed\" | \"unavailable\" | \"not-applicable\";\nexport interface NoScoreContribution {\n    readonly state: \"not-scored\";\n}\nexport interface EarnedScoreContribution {\n    readonly state: \"earned\";\n    readonly points: number;\n    readonly earned: number;\n}\nexport interface UnavailableScoreContribution {\n    readonly state: \"unavailable\";\n    readonly points: number;\n    readonly reason: \"source-unavailable\" | \"evaluation-errored\" | \"not-applicable\";\n}\nexport type ScoreContribution = NoScoreContribution | EarnedScoreContribution | UnavailableScoreContribution;\nexport interface AssertionCollectionReceipt {\n    readonly examined: number;\n    readonly matched: number;\n    readonly mismatched: number;\n    readonly unavailable: number;\n    readonly knownTotal: number | null;\n    readonly complete: boolean;\n    readonly exhaustive: boolean;\n    readonly decisive: boolean;\n}\nexport type SealedAssertionResult = {\n    readonly state: \"matched\";\n    readonly gate: \"not-gate\" | \"satisfied\";\n    readonly score: NoScoreContribution | EarnedScoreContribution;\n    /** Bounded evaluator diagnostics, including ToolMatch evidence paths. */\n    readonly diagnostic?: BoundedJsonObject;\n    readonly receipt?: AssertionCollectionReceipt;\n} | {\n    readonly state: \"mismatched\";\n    readonly reason: \"condition-not-met\";\n    readonly gate: \"not-gate\" | \"failed\";\n    readonly score: NoScoreContribution | EarnedScoreContribution;\n    readonly diagnostic?: BoundedJsonObject;\n    readonly receipt?: AssertionCollectionReceipt;\n} | {\n    readonly state: \"unavailable\";\n    readonly reason: \"evidence-unavailable\" | \"source-unavailable\" | \"redacted\";\n    readonly gate: \"not-gate\" | \"unavailable\";\n    readonly score: NoScoreContribution | UnavailableScoreContribution;\n    readonly diagnostic?: BoundedJsonObject;\n    readonly receipt?: AssertionCollectionReceipt;\n} | {\n    readonly state: \"errored\";\n    readonly reason: \"evaluator-failed\" | \"producer-interrupted\" | \"invalid-subject\";\n    readonly gate: \"not-gate\" | \"unavailable\";\n    readonly score: NoScoreContribution | UnavailableScoreContribution;\n    readonly diagnostic?: BoundedJsonObject;\n    readonly receipt?: AssertionCollectionReceipt;\n} | {\n    readonly state: \"not-applicable\";\n    readonly reason: \"coverage-not-applicable\";\n    readonly gate: \"not-gate\" | \"not-applicable\";\n    readonly score: NoScoreContribution | UnavailableScoreContribution;\n    readonly diagnostic?: BoundedJsonObject;\n    readonly receipt?: AssertionCollectionReceipt;\n};\nexport type AssertionCriterionRecord = {\n    readonly state: \"available\";\n    readonly value: WritableCriterionEnvelope;\n} | {\n    readonly state: \"unavailable\";\n    readonly reason: \"not-recorded\";\n};\nexport type AssertionCriterionRecordOuter = {\n    readonly state: \"available\";\n    readonly value: BoundedJsonObject;\n} | {\n    readonly state: \"unavailable\";\n    readonly reason: \"not-recorded\";\n};\nexport interface AssertionMaterials<BlobRef> {\n    readonly source: AssertionMaterial<BlobRef>;\n    readonly evidence: readonly AssertionMaterial<BlobRef>[];\n    readonly coverage: AssertionCoverage;\n    readonly limitations: readonly AssertionLimitation[];\n}\nexport interface AssertionEvaluation {\n    readonly observed: AssertionFactValue;\n    readonly receipt?: AssertionCollectionReceipt;\n}\nexport interface AssertionDecision {\n    readonly result: \"matched\" | \"mismatched\" | \"unavailable\" | \"errored\" | \"not-applicable\";\n    readonly reason: \"condition-not-met\" | \"evidence-unavailable\" | \"source-unavailable\" | \"redacted\" | \"evaluator-failed\" | \"producer-interrupted\" | \"invalid-subject\" | \"coverage-not-applicable\" | null;\n    readonly gate: GateDisposition;\n}\nexport function sealedAssertionResult(entry: Pick<AssertionEntry<unknown>, \"decision\" | \"contribution\" | \"evaluation\">): SealedAssertionResult {\n    const receipt = entry.evaluation.receipt === undefined ? {} : { receipt: entry.evaluation.receipt };\n    switch (entry.decision.result) {\n        case \"matched\":\n            return Object.freeze({ state: \"matched\", gate: entry.decision.gate as \"not-gate\" | \"satisfied\", score: entry.contribution as NoScoreContribution | EarnedScoreContribution, ...receipt });\n        case \"mismatched\":\n            return Object.freeze({ state: \"mismatched\", reason: \"condition-not-met\", gate: entry.decision.gate as \"not-gate\" | \"failed\", score: entry.contribution as NoScoreContribution | EarnedScoreContribution, ...receipt });\n        case \"unavailable\":\n            return Object.freeze({ state: \"unavailable\", reason: entry.decision.reason as \"evidence-unavailable\" | \"source-unavailable\" | \"redacted\", gate: entry.decision.gate as \"not-gate\" | \"unavailable\", score: entry.contribution as NoScoreContribution | UnavailableScoreContribution, ...receipt });\n        case \"errored\":\n            return Object.freeze({ state: \"errored\", reason: entry.decision.reason as \"evaluator-failed\" | \"producer-interrupted\" | \"invalid-subject\", gate: entry.decision.gate as \"not-gate\" | \"unavailable\", score: entry.contribution as NoScoreContribution | UnavailableScoreContribution, ...receipt });\n        case \"not-applicable\":\n            return Object.freeze({ state: \"not-applicable\", reason: \"coverage-not-applicable\", gate: entry.decision.gate as \"not-gate\" | \"not-applicable\", score: entry.contribution as NoScoreContribution | UnavailableScoreContribution, ...receipt });\n    }\n}\nexport type ExplanationRetention = {\n    readonly state: \"retained\";\n    readonly value: AssertionFactValue;\n} | {\n    readonly state: \"unavailable\";\n    readonly reason: \"not-recorded\";\n};\n/** The sole current semantic entry. Each fact has exactly one durable owner. */\nexport interface AssertionEntry<BlobRef> {\n    readonly entryId: AssertionEntryId;\n    readonly display: AssertionDisplay;\n    readonly criterion: AssertionCriterionRecord;\n    readonly materials: AssertionMaterials<BlobRef>;\n    readonly evaluation: AssertionEvaluation;\n    readonly decision: AssertionDecision;\n    readonly policy: AssertionDecisionPolicy;\n    readonly contribution: ScoreContribution;\n    readonly explanationRetention: ExplanationRetention;\n}\n/**\n * Reader framing intentionally leaves `criterion` as bounded JSON.  This\n * lets a bad plugin or future criterion affect its entry only after every\n * other entry boundary has already been verified.\n */\nexport interface AssertionEntryOuter<BlobRef> {\n    readonly entryId: AssertionEntryId;\n    readonly display: AssertionDisplay;\n    readonly criterion: AssertionCriterionRecordOuter;\n    readonly materials: AssertionMaterials<BlobRef>;\n    readonly evaluation: AssertionEvaluation;\n    readonly decision: AssertionDecision;\n    readonly policy: AssertionDecisionPolicy;\n    readonly contribution: ScoreContribution;\n    readonly explanationRetention: ExplanationRetention;\n}\nexport interface AssertionsDocument<BlobRef> {\n    readonly entries: readonly AssertionEntry<BlobRef>[];\n}\nexport interface AssertionsDocumentOuter<BlobRef> {\n    readonly entries: readonly AssertionEntryOuter<BlobRef>[];\n}\nexport type AssertionEntryRead<BlobRef> = {\n    readonly state: \"available\";\n    readonly entry: AssertionEntry<BlobRef>;\n} | {\n    readonly state: \"unsupported\";\n    readonly entry: AssertionEntryOuter<BlobRef>;\n    readonly reason: \"builtin-unknown\" | \"third-party-schema-unavailable\";\n} | {\n    readonly state: \"invalid\";\n    readonly entry: AssertionEntryOuter<BlobRef>;\n    readonly reason: \"criterion-envelope-invalid\" | \"criterion-data-invalid\";\n};\nexport interface AssertionsProjection<BlobRef> {\n    readonly entries: readonly AssertionEntryRead<BlobRef>[];\n}\n"]}