@usefragments/core 1.10.2 → 2.0.0

package/src/evaluation/evaluation-v2-receipt-v1.test.ts

@@ -0,0 +1,772 @@
+import { describe, expect, it } from "vitest";
+import { buildAnalysisPlanV1, type CoverageRegionV1 } from "../analysis-plan/index.js";
+import { contractHash } from "../contract/hash.js";
+import { projectContractPreimage } from "../contract/preimage.js";
+import { evaluationReceiptIdFromDigest } from "../domain-ids.js";
+import { FactIndex } from "../facts/fact-index.js";
+import { makeTokenDefinitionFact } from "../facts/builders.js";
+import { repositoryBindingDigestV1 } from "../repository-binding.js";
+import {
+  EVALUATOR_VERSION_V2,
+  evaluate,
+  evaluationInputDigestV2,
+  evaluationResultDigestV2,
+  evaluationInputV2Schema,
+  evaluationReceiptDigestV1,
+  evaluationReceiptMintInputV1Schema,
+  evaluationReceiptV1Schema,
+  evaluationResultV2Schema,
+  parseEvaluationReceiptV1,
+  providerProofDigestV1,
+  type EvaluationInputV2,
+  type EvaluationReceiptMintInputV1,
+  type EvaluationReceiptSemanticV1,
+  type ProviderProofV1,
+} from "./index.js";
+
+const A = "a".repeat(64);
+const B = "b".repeat(64);
+const C = "c".repeat(64);
+
+const binding = {
+  provider: "github",
+  providerInstanceId: "github.com",
+  repositoryExternalId: "R_1",
+  bindingId: "binding_1",
+};
+
+const CONTRACT_PREIMAGE = projectContractPreimage({
+  components: [],
+  tokens: [],
+  canonicalMappings: [],
+  policy: {},
+});
+const FCID = contractHash(CONTRACT_PREIMAGE);
+
+function plan() {
+  return buildAnalysisPlanV1({
+    binding,
+    source: {
+      commitId: "head-sha",
+      defaultBranch: "main",
+      acquiredBy: "github_app",
+    },
+    contract: { fcid: FCID, artifactDigest: B },
+    config: { path: "fragments.config.ts", digest: C },
+    profile: { id: "react-web-v1", version: "1", capabilities: ["tsx"] },
+    regions: [
+      {
+        regionId: "tsx",
+        pathPattern: "src/**/*.tsx",
+        kind: "component_source",
+        language: "typescript",
+        required: true,
+        requiredDialects: ["tsx"],
+        analyzer: { id: "react", interfaceVersion: "1", implementationVersion: "1" },
+      },
+    ],
+    limits: {
+      maxSourceFiles: 1_000,
+      maxSourceBytes: 10_000_000,
+      maxFileBytes: 1_000_000,
+      maxFacts: 10_000,
+      maxRegions: 100,
+      maxDiagnostics: 1_000,
+      maxDurationMs: 60_000,
+    },
+    evaluatorVersion: "evaluation-kernel:v2",
+    createdAt: "2026-09-01T00:00:00.000Z",
+  });
+}
+
+const coverage: CoverageRegionV1[] = [
+  { regionId: "tsx", state: "analyzed", fileCount: 4, byteCount: 400, diagnosticIds: [] },
+];
+
+function evaluationInput(): EvaluationInputV2 {
+  const analysisPlan = plan();
+  return {
+    schemaVersion: 2,
+    binding,
+    analysisPlan,
+    contract: { fcid: analysisPlan.contract.fcid, preimage: CONTRACT_PREIMAGE, active: true },
+    factSchemaVersion: "facts:v1",
+    facts: new FactIndex(),
+    factsDigest: B,
+    coverage,
+    policy: { failOnWarnings: false },
+    trust: { source: "verified", mappings: {} },
+    waivers: [],
+    integrity: {
+      governance: "healthy",
+      inertConfigDiagnosticCount: 0,
+      profile: { state: "known", profileId: "react-web-v1", profileVersion: "1" },
+      facts: { state: "healthy", coalescedDuplicateCount: 0 },
+    },
+    evaluatedAt: Date.UTC(2026, 8, 1),
+    evaluatorVersion: "evaluation-kernel:v2",
+  };
+}
+
+function providerProof(): ProviderProofV1 {
+  const semantic = {
+    schemaVersion: 1 as const,
+    adapterId: "github-app",
+    adapterVersion: "1",
+    providerInstanceId: "github.com",
+    bindingDigest: repositoryBindingDigestV1(binding),
+    repositoryExternalId: "R_1",
+    sourceCommitId: "head-sha",
+    eventExternalId: "delivery-1",
+    changeExternalId: "42",
+    publisherExternalId: "fragments-app",
+  };
+  return { ...semantic, proofDigest: providerProofDigestV1(semantic) };
+}
+
+function receiptSemantic(
+  overrides: Partial<EvaluationReceiptSemanticV1> = {}
+): EvaluationReceiptSemanticV1 {
+  return {
+    schemaVersion: 1,
+    trust: "source_verified",
+    authority: "enforcement_eligible",
+    binding,
+    sourceCommitId: "head-sha",
+    fcid: FCID,
+    analysisPlanDigest: plan().digest,
+    factsDigest: B,
+    inputDigest: C,
+    resultDigest: A,
+    evaluatorVersion: "evaluation-kernel:v2",
+    providerProof: providerProof(),
+    ...overrides,
+  };
+}
+
+describe("EvaluationInputV2", () => {
+  it("accepts the complete facts-only input and rejects unknown keys", () => {
+    expect(evaluationInputV2Schema.parse(evaluationInput())).toMatchObject({ schemaVersion: 2 });
+    expect(() => evaluationInputV2Schema.parse({ ...evaluationInput(), summary: {} })).toThrow();
+  });
+
+  it("rejects plan/binding/FCID/evaluator mismatch and missing required coverage", () => {
+    expect(() =>
+      evaluationInputV2Schema.parse({
+        ...evaluationInput(),
+        binding: { ...binding, repositoryExternalId: "R_other" },
+      })
+    ).toThrow();
+    expect(() =>
+      evaluationInputV2Schema.parse({
+        ...evaluationInput(),
+        contract: { ...evaluationInput().contract, fcid: B },
+      })
+    ).toThrow();
+    expect(() => evaluationInputV2Schema.parse({ ...evaluationInput(), coverage: [] })).toThrow();
+    expect(() =>
+      evaluationInputV2Schema.parse({ ...evaluationInput(), evaluatorVersion: "other" })
+    ).toThrow();
+  });
+
+  it("rejects empty/duplicate waiver matches and malformed integrity unions", () => {
+    const waiver = {
+      waiverId: "w-1",
+      scope: { kind: "rule" as const, ruleId: "components/prefer-library" },
+      matchedFindingFingerprints: ["f-1"],
+      reason: "Migration in progress",
+    };
+    expect(() =>
+      evaluationInputV2Schema.parse({
+        ...evaluationInput(),
+        waivers: [{ ...waiver, matchedFindingFingerprints: [] }],
+      })
+    ).toThrow();
+    expect(() =>
+      evaluationInputV2Schema.parse({
+        ...evaluationInput(),
+        waivers: [{ ...waiver, matchedFindingFingerprints: ["f-1", "f-1"] }],
+      })
+    ).toThrow();
+    expect(() =>
+      evaluationInputV2Schema.parse({
+        ...evaluationInput(),
+        integrity: {
+          ...evaluationInput().integrity,
+          profile: { state: "known", profileId: "react-web-v1" },
+        },
+      })
+    ).toThrow();
+  });
+
+  it("enforces the analysis-plan fact limit", () => {
+    const basePlan = plan();
+    const {
+      schemaVersion: _schemaVersion,
+      analysisPlanId: _analysisPlanId,
+      obligationsDigest: _obligationsDigest,
+      digest: _digest,
+      ...planInput
+    } = basePlan;
+    const limitedPlan = buildAnalysisPlanV1({
+      ...planInput,
+      limits: { ...planInput.limits, maxFacts: 1 },
+    });
+    const facts = new FactIndex();
+    facts.addMany([
+      makeTokenDefinitionFact({ name: "--one", value: "1px" }),
+      makeTokenDefinitionFact({ name: "--two", value: "2px" }),
+    ]);
+    expect(() =>
+      evaluationInputV2Schema.parse({
+        ...evaluationInput(),
+        analysisPlan: limitedPlan,
+        facts,
+      })
+    ).toThrow(/Fact count/u);
+  });
+});
+
+describe("EvaluationResultV2", () => {
+  it("preserves reasons, counts, derived output, and integrity explanation", () => {
+    const result = {
+      schemaVersion: 2,
+      verdict: "pass",
+      reasons: [],
+      findings: [],
+      counts: { blocked: 0, advisory: 0, pendingCloudTrust: 0 },
+      derived: { warnPresent: false, gatingFindingsPresent: false },
+      coverageSummary: {
+        plannedRegions: 1,
+        observedRegions: 1,
+        requiredRegions: 1,
+        requiredByState: {
+          analyzed: 1,
+          unsupported: 0,
+          excluded_by_contract: 0,
+          skipped_limit: 0,
+          failed: 0,
+        },
+        optionalByState: {
+          analyzed: 0,
+          unsupported: 0,
+          excluded_by_contract: 0,
+          skipped_limit: 0,
+          failed: 0,
+        },
+        eligibleFiles: 4,
+        analyzedFiles: 4,
+        analyzedBytes: 400,
+      },
+      integrity: {
+        fcidVerified: true,
+        analysisPlanVerified: true,
+        factIntegrity: "healthy",
+        requiredCoverage: "complete",
+        governance: "healthy",
+        profile: "known",
+      },
+      inputDigest: A,
+      resultDigest: B,
+    } as const;
+    expect(evaluationResultV2Schema.parse(result)).toMatchObject({ verdict: "pass" });
+    expect(() =>
+      evaluationResultV2Schema.parse({
+        ...result,
+        reasons: ["factConflict", "factConflict"],
+      })
+    ).toThrow(/unique/u);
+  });
+
+  it("holds an integrity-class reason at indeterminate even beside blocked findings", () => {
+    // Mirrors the kernel: `inertConfigPresent` (an INTEGRITY reason) beside
+    // `blockedFindings` is `indeterminate`, never `block`.
+    const result = {
+      schemaVersion: 2,
+      verdict: "indeterminate",
+      reasons: ["inertConfigPresent", "blockedFindings"],
+      findings: [
+        {
+          fingerprint: "f-block",
+          ruleId: "r-block",
+          severity: "error",
+          state: "blocked",
+          stateReasons: [],
+        },
+      ],
+      counts: { blocked: 1, advisory: 0, pendingCloudTrust: 0 },
+      derived: { warnPresent: false, gatingFindingsPresent: true },
+      coverageSummary: {
+        plannedRegions: 1,
+        observedRegions: 1,
+        requiredRegions: 1,
+        requiredByState: {
+          analyzed: 1,
+          unsupported: 0,
+          excluded_by_contract: 0,
+          skipped_limit: 0,
+          failed: 0,
+        },
+        optionalByState: {
+          analyzed: 0,
+          unsupported: 0,
+          excluded_by_contract: 0,
+          skipped_limit: 0,
+          failed: 0,
+        },
+        eligibleFiles: 1,
+        analyzedFiles: 1,
+        analyzedBytes: 100,
+      },
+      integrity: {
+        fcidVerified: true,
+        analysisPlanVerified: true,
+        factIntegrity: "healthy",
+        requiredCoverage: "complete",
+        governance: "healthy",
+        profile: "known",
+      },
+      inputDigest: A,
+      resultDigest: B,
+    } as const;
+    expect(evaluationResultV2Schema.parse(result)).toMatchObject({ verdict: "indeterminate" });
+    expect(() => evaluationResultV2Schema.parse({ ...result, verdict: "block" })).toThrow(
+      /verdict must be indeterminate/u
+    );
+  });
+
+  it("rejects impossible counts, derived values, findings, reasons, and coverage", () => {
+    const result = evaluationResultV2Schema.parse({
+      schemaVersion: 2,
+      verdict: "pass",
+      reasons: [],
+      findings: [],
+      counts: { blocked: 0, advisory: 0, pendingCloudTrust: 0 },
+      derived: { warnPresent: false, gatingFindingsPresent: false },
+      coverageSummary: {
+        plannedRegions: 1,
+        observedRegions: 1,
+        requiredRegions: 1,
+        requiredByState: {
+          analyzed: 1,
+          unsupported: 0,
+          excluded_by_contract: 0,
+          skipped_limit: 0,
+          failed: 0,
+        },
+        optionalByState: {
+          analyzed: 0,
+          unsupported: 0,
+          excluded_by_contract: 0,
+          skipped_limit: 0,
+          failed: 0,
+        },
+        eligibleFiles: 4,
+        analyzedFiles: 4,
+        analyzedBytes: 400,
+      },
+      integrity: {
+        fcidVerified: true,
+        analysisPlanVerified: true,
+        factIntegrity: "healthy",
+        requiredCoverage: "complete",
+        governance: "healthy",
+        profile: "known",
+      },
+      inputDigest: A,
+      resultDigest: B,
+    });
+
+    expect(() =>
+      evaluationResultV2Schema.parse({
+        ...result,
+        counts: { ...result.counts, blocked: 1 },
+      })
+    ).toThrow(/count must match/u);
+    expect(() =>
+      evaluationResultV2Schema.parse({
+        ...result,
+        findings: [
+          {
+            fingerprint: "f-warn",
+            ruleId: "r-warn",
+            severity: "warn",
+            state: "advisory",
+            stateReasons: [],
+          },
+        ],
+        counts: { blocked: 0, advisory: 1, pendingCloudTrust: 0 },
+        derived: { ...result.derived, warnPresent: false },
+      })
+    ).toThrow(/warnPresent/u);
+    expect(() =>
+      evaluationResultV2Schema.parse({
+        ...result,
+        findings: [
+          {
+            fingerprint: "f-1",
+            ruleId: "r-1",
+            severity: "error",
+            state: "advisory",
+            stateReasons: [],
+          },
+          {
+            fingerprint: "f-1",
+            ruleId: "r-2",
+            severity: "info",
+            state: "advisory",
+            stateReasons: [],
+          },
+        ],
+        counts: { blocked: 0, advisory: 2, pendingCloudTrust: 0 },
+      })
+    ).toThrow(/fingerprints must be unique/u);
+    expect(() =>
+      evaluationResultV2Schema.parse({
+        ...result,
+        reasons: ["factConflict"],
+      })
+    ).toThrow(/factConflict must match/u);
+    expect(() =>
+      evaluationResultV2Schema.parse({
+        ...result,
+        coverageSummary: { ...result.coverageSummary, observedRegions: 2 },
+      })
+    ).toThrow(/counts must reconcile/u);
+  });
+
+  it("never treats incomplete or absent required coverage as a pass", () => {
+    const base = {
+      schemaVersion: 2 as const,
+      reasons: ["requiredCoverageMissing" as const],
+      findings: [],
+      counts: { blocked: 0, advisory: 0, pendingCloudTrust: 0 },
+      derived: { warnPresent: false, gatingFindingsPresent: false },
+      coverageSummary: {
+        plannedRegions: 1,
+        observedRegions: 1,
+        requiredRegions: 0,
+        requiredByState: {
+          analyzed: 0,
+          unsupported: 0,
+          excluded_by_contract: 0,
+          skipped_limit: 0,
+          failed: 0,
+        },
+        optionalByState: {
+          analyzed: 1,
+          unsupported: 0,
+          excluded_by_contract: 0,
+          skipped_limit: 0,
+          failed: 0,
+        },
+        eligibleFiles: 1,
+        analyzedFiles: 1,
+        analyzedBytes: 100,
+      },
+      integrity: {
+        fcidVerified: true,
+        analysisPlanVerified: true,
+        factIntegrity: "healthy" as const,
+        requiredCoverage: "no_required_regions" as const,
+        governance: "healthy" as const,
+        profile: "known" as const,
+      },
+      inputDigest: A,
+      resultDigest: B,
+    };
+    expect(evaluationResultV2Schema.parse({ ...base, verdict: "indeterminate" })).toMatchObject({
+      verdict: "indeterminate",
+    });
+    expect(() => evaluationResultV2Schema.parse({ ...base, verdict: "pass" })).toThrow(
+      /verdict must be indeterminate/u
+    );
+
+    expect(() =>
+      evaluationResultV2Schema.parse({
+        ...base,
+        verdict: "pass",
+        reasons: ["requiredCoverageIncomplete"],
+        coverageSummary: {
+          ...base.coverageSummary,
+          requiredRegions: 1,
+          requiredByState: { ...base.coverageSummary.requiredByState, failed: 1 },
+          optionalByState: { ...base.coverageSummary.optionalByState, analyzed: 0 },
+        },
+        integrity: { ...base.integrity, requiredCoverage: "incomplete" },
+      })
+    ).toThrow(/verdict must be indeterminate/u);
+  });
+
+  it("preserves warnPresent when same-fingerprint warning evidence collapses under an error", () => {
+    const collapsed = {
+      schemaVersion: 2 as const,
+      verdict: "pass" as const,
+      reasons: [],
+      findings: [
+        {
+          fingerprint: "same-fingerprint",
+          ruleId: "harder-rule",
+          severity: "error" as const,
+          state: "advisory" as const,
+          stateReasons: ["harder same-fingerprint evidence retained"],
+        },
+      ],
+      counts: { blocked: 0, advisory: 1, pendingCloudTrust: 0 },
+      derived: { warnPresent: true, gatingFindingsPresent: false },
+      coverageSummary: {
+        plannedRegions: 1,
+        observedRegions: 1,
+        requiredRegions: 1,
+        requiredByState: {
+          analyzed: 1,
+          unsupported: 0,
+          excluded_by_contract: 0,
+          skipped_limit: 0,
+          failed: 0,
+        },
+        optionalByState: {
+          analyzed: 0,
+          unsupported: 0,
+          excluded_by_contract: 0,
+          skipped_limit: 0,
+          failed: 0,
+        },
+        eligibleFiles: 1,
+        analyzedFiles: 1,
+        analyzedBytes: 100,
+      },
+      integrity: {
+        fcidVerified: true,
+        analysisPlanVerified: true,
+        factIntegrity: "healthy" as const,
+        requiredCoverage: "complete" as const,
+        governance: "healthy" as const,
+        profile: "known" as const,
+      },
+      inputDigest: A,
+      resultDigest: B,
+    };
+    expect(evaluationResultV2Schema.parse(collapsed).derived.warnPresent).toBe(true);
+  });
+});
+
+describe("evaluate V2", () => {
+  it("validates stored semantic digests without a second evaluation", () => {
+    const input = evaluationInput();
+    const result = evaluate(input);
+    const { resultDigest, ...semantic } = result;
+    expect(evaluationInputDigestV2(input)).toBe(result.inputDigest);
+    expect(evaluationResultDigestV2(semantic)).toBe(resultDigest);
+    expect(evaluationResultDigestV2({ ...semantic, verdict: "block" })).not.toBe(resultDigest);
+    expect(evaluationInputDigestV2({ ...input, evaluatedAt: input.evaluatedAt + 1 })).not.toBe(
+      result.inputDigest
+    );
+  });
+
+  it("produces the checked-in deterministic pass result for complete healthy evidence", () => {
+    const result = evaluate(evaluationInput());
+
+    expect(result).toMatchObject({
+      schemaVersion: 2,
+      verdict: "pass",
+      reasons: [],
+      counts: { blocked: 0, advisory: 0, pendingCloudTrust: 0 },
+      integrity: {
+        fcidVerified: true,
+        analysisPlanVerified: true,
+        factIntegrity: "healthy",
+        requiredCoverage: "complete",
+        governance: "healthy",
+        profile: "known",
+      },
+    });
+    expect(result.inputDigest).toBe(
+      "9c89d84e33f7569030440720c3c467622507c5aa0d1e9ca6eeb0fc4f5e045f7e"
+    );
+    expect(result.resultDigest).toBe(
+      "c3fe439dd196bdd7b9ca2d4d60e620282cebd9302f94af8e6ce509199471ef57"
+    );
+  });
+
+  it.each([
+    {
+      name: "unsupported required coverage",
+      patch: {
+        coverage: [
+          {
+            regionId: "tsx",
+            state: "unsupported" as const,
+            fileCount: 4,
+            byteCount: 400,
+            diagnosticIds: ["analysis.unsupported.tsx"],
+          },
+        ],
+      },
+      reason: "requiredCoverageIncomplete",
+    },
+    {
+      name: "canonical fact conflict",
+      patch: {
+        integrity: {
+          ...evaluationInput().integrity,
+          facts: {
+            state: "conflict" as const,
+            coalescedDuplicateCount: 0,
+            conflicts: [
+              {
+                canonicalKey: "token:--space-2",
+                factKind: "token_definition",
+                state: "conflict" as const,
+                values: [
+                  {
+                    valueDigest: A,
+                    factIds: ["fact-a"],
+                    analyzerIds: ["css"],
+                    evidenceRefs: ["src/a.css:1"],
+                  },
+                  {
+                    valueDigest: B,
+                    factIds: ["fact-b"],
+                    analyzerIds: ["scss"],
+                    evidenceRefs: ["src/b.scss:1"],
+                  },
+                ],
+              },
+            ],
+          },
+        },
+      },
+      reason: "factConflict",
+    },
+    {
+      name: "unknown profile",
+      patch: {
+        integrity: {
+          ...evaluationInput().integrity,
+          profile: { state: "unknown" as const, profileId: "react-web-v1" },
+        },
+      },
+      reason: "unknownAnalysisProfile",
+    },
+  ])("fails closed for $name", ({ patch, reason }) => {
+    const result = evaluate({ ...evaluationInput(), ...patch });
+    expect(result.verdict).toBe("indeterminate");
+    expect(result.reasons).toContain(reason);
+  });
+
+  it("normalizes coverage, waiver, and provenance order before digesting", () => {
+    const first = evaluationInput();
+    first.waivers = [
+      {
+        waiverId: "waiver-2",
+        scope: { kind: "rule", ruleId: "r-2" },
+        matchedFindingFingerprints: ["finding-b", "finding-a"],
+        reason: "Migration",
+      },
+      {
+        waiverId: "waiver-1",
+        scope: { kind: "finding", fingerprint: "finding-c" },
+        matchedFindingFingerprints: ["finding-c"],
+        reason: "Exception",
+      },
+    ];
+    const second = evaluationInput();
+    second.waivers = [
+      first.waivers[1]!,
+      {
+        ...first.waivers[0]!,
+        matchedFindingFingerprints: ["finding-a", "finding-b"],
+      },
+    ];
+
+    expect(evaluate(first).inputDigest).toBe(evaluate(second).inputDigest);
+    expect(evaluate(first).resultDigest).toBe(evaluate(second).resultDigest);
+  });
+
+  it("rejects evaluator and fact-schema versions it cannot interpret", () => {
+    expect(EVALUATOR_VERSION_V2).toBe("evaluation-kernel:v2");
+    expect(() =>
+      evaluate({ ...evaluationInput(), evaluatorVersion: "evaluation-kernel:v3" })
+    ).toThrow(/Unsupported evaluator version/u);
+    expect(() => evaluate({ ...evaluationInput(), factSchemaVersion: "facts:v2" })).toThrow(
+      /Unsupported fact schema version/u
+    );
+  });
+});
+
+describe("EvaluationReceiptV1", () => {
+  it("has a checked-in canonical digest and verifies all derived identity", () => {
+    const semantic = receiptSemantic();
+    const digest = evaluationReceiptDigestV1(semantic);
+    expect(digest).toBe("09b0294ed27a24f89d0432b19c519b4ad5c2bceffc982d2aa1fa370b5ac6b016");
+    const receipt = {
+      ...semantic,
+      receiptId: evaluationReceiptIdFromDigest(digest),
+      mintedAt: "2026-09-01T01:00:00.000Z",
+      digest,
+    };
+    expect(parseEvaluationReceiptV1(receipt)).toEqual(evaluationReceiptV1Schema.parse(receipt));
+  });
+
+  it("pins both input and result digests", () => {
+    const base = evaluationReceiptDigestV1(receiptSemantic());
+    expect(evaluationReceiptDigestV1(receiptSemantic({ inputDigest: B }))).not.toBe(base);
+    expect(evaluationReceiptDigestV1(receiptSemantic({ resultDigest: C }))).not.toBe(base);
+  });
+
+  it.each(["local", "ci_attested", "unknown"] as const)("keeps %s evidence advisory", (trust) => {
+    const semantic = receiptSemantic({ trust, authority: "advisory", providerProof: undefined });
+    expect(evaluationReceiptDigestV1(semantic)).toMatch(/^[0-9a-f]{64}$/u);
+    expect(() =>
+      evaluationReceiptDigestV1({ ...semantic, authority: "enforcement_eligible" })
+    ).toThrow();
+  });
+
+  it("requires exact provider proof for source-verified enforcement", () => {
+    expect(() =>
+      evaluationReceiptDigestV1(
+        receiptSemantic({ providerProof: { ...providerProof(), sourceCommitId: "other" } })
+      )
+    ).toThrow();
+    expect(() =>
+      evaluationReceiptDigestV1(receiptSemantic({ providerProof: undefined }))
+    ).toThrow();
+    expect(() =>
+      evaluationReceiptDigestV1(
+        receiptSemantic({ authority: "advisory", providerProof: undefined })
+      )
+    ).toThrow();
+    expect(() =>
+      evaluationReceiptDigestV1(receiptSemantic({ trust: "ci_attested", authority: "advisory" }))
+    ).toThrow();
+  });
+
+  it("does not let an external mint payload submit authority or proof", () => {
+    const external = {
+      schemaVersion: 1,
+      trust: "ci_attested",
+      binding,
+      sourceCommitId: "head-sha",
+      fcid: A,
+      analysisPlanDigest: plan().digest,
+      factsDigest: B,
+      inputDigest: C,
+      resultDigest: A,
+      evaluatorVersion: "evaluation-kernel:v2",
+    } satisfies EvaluationReceiptMintInputV1;
+    // @ts-expect-error Source-verified trust is derived with provider proof by the application.
+    const sourceVerifiedMintInput: EvaluationReceiptMintInputV1 = {
+      ...external,
+      trust: "source_verified",
+    };
+    void sourceVerifiedMintInput;
+    expect(evaluationReceiptMintInputV1Schema.parse(external)).toEqual(external);
+    expect(() =>
+      evaluationReceiptMintInputV1Schema.parse({ ...external, authority: "enforcement_eligible" })
+    ).toThrow();
+    expect(() =>
+      evaluationReceiptMintInputV1Schema.parse({ ...external, providerProof: providerProof() })
+    ).toThrow();
+  });
+});