@sourcey/catalog-verifier 1.1.36 → 1.2.1

package/dist/modules/provenance/src/material-claims.d.ts

@@ -1,262 +0,0 @@
-import { type Digest } from "provenry/primitives";
-import { z } from "zod";
-import type { CoverageRequirement } from "../../../contracts/policies/src/index.js";
-import { type ListingRevision } from "../../../contracts/revisions/src/index.js";
-declare const materialClaimSchema: z.ZodObject<{
-    policy_path: z.ZodString;
-    path: z.ZodString;
-    value_digest: z.ZodString;
-    semantic_type: z.ZodEnum<{
-        access: "access";
-        boolean: "boolean";
-        composition: "composition";
-        currency: "currency";
-        domain: "domain";
-        duration: "duration";
-        editorial_text: "editorial_text";
-        eligibility_composition: "eligibility_composition";
-        eligibility_value: "eligibility_value";
-        exact_text: "exact_text";
-        lifecycle_state: "lifecycle_state";
-        money_amount: "money_amount";
-        number: "number";
-        percentage: "percentage";
-        qualifier: "qualifier";
-        source_authority: "source_authority";
-        structured_value: "structured_value";
-        taxonomy: "taxonomy";
-        url: "url";
-    }>;
-    proof_kinds: z.ZodArray<z.ZodEnum<{
-        attested: "attested";
-        derived: "derived";
-        editorial: "editorial";
-        observed: "observed";
-    }>>;
-    derivation_rules: z.ZodArray<z.ZodString>;
-    guidance: z.ZodString;
-    depends_on: z.ZodArray<z.ZodString>;
-    claim_id: z.ZodString;
-}, z.core.$strict>;
-export declare const materialClaimPlanSchema: z.ZodObject<{
-    plan_contract: z.ZodLiteral<"sourcey.material-claim-plan/v1alpha1">;
-    coverage_policy_digest: z.ZodString;
-    subject: z.ZodDiscriminatedUnion<[z.ZodObject<{
-        subject_type: z.ZodLiteral<"entity">;
-        entity_id: z.ZodString;
-        revision_digest: z.ZodString;
-    }, z.core.$strict>, z.ZodObject<{
-        subject_type: z.ZodLiteral<"program">;
-        entity_id: z.ZodString;
-        program_id: z.ZodString;
-        revision_digest: z.ZodString;
-    }, z.core.$strict>, z.ZodObject<{
-        subject_type: z.ZodLiteral<"offer">;
-        entity_id: z.ZodString;
-        program_id: z.ZodOptional<z.ZodString>;
-        offer_id: z.ZodString;
-        revision_digest: z.ZodString;
-    }, z.core.$strict>], "subject_type">;
-    claims: z.ZodArray<z.ZodObject<{
-        policy_path: z.ZodString;
-        path: z.ZodString;
-        value_digest: z.ZodString;
-        semantic_type: z.ZodEnum<{
-            access: "access";
-            boolean: "boolean";
-            composition: "composition";
-            currency: "currency";
-            domain: "domain";
-            duration: "duration";
-            editorial_text: "editorial_text";
-            eligibility_composition: "eligibility_composition";
-            eligibility_value: "eligibility_value";
-            exact_text: "exact_text";
-            lifecycle_state: "lifecycle_state";
-            money_amount: "money_amount";
-            number: "number";
-            percentage: "percentage";
-            qualifier: "qualifier";
-            source_authority: "source_authority";
-            structured_value: "structured_value";
-            taxonomy: "taxonomy";
-            url: "url";
-        }>;
-        proof_kinds: z.ZodArray<z.ZodEnum<{
-            attested: "attested";
-            derived: "derived";
-            editorial: "editorial";
-            observed: "observed";
-        }>>;
-        derivation_rules: z.ZodArray<z.ZodString>;
-        guidance: z.ZodString;
-        depends_on: z.ZodArray<z.ZodString>;
-        claim_id: z.ZodString;
-    }, z.core.$strict>>;
-    plan_digest: z.ZodString;
-}, z.core.$strict>;
-declare const materialClaimMatchBindingCoreSchema: z.ZodObject<{
-    source_id: z.ZodString;
-    capture_digest: z.ZodString;
-    normalized_object_digest: z.ZodString;
-    adapter_id: z.ZodString;
-    adapter_digest: z.ZodString;
-    proof_kind: z.ZodEnum<{
-        attested: "attested";
-        derived: "derived";
-        editorial: "editorial";
-        observed: "observed";
-    }>;
-    derivation_rule: z.ZodNullable<z.ZodEnum<{
-        "consideration-from-benefits": "consideration-from-benefits";
-        "contact-access-from-first-party-mailto": "contact-access-from-first-party-mailto";
-        "eligibility-composition-from-criteria": "eligibility-composition-from-criteria";
-        "first-party-access-operator": "first-party-access-operator";
-        "form-access-from-first-party-application": "form-access-from-first-party-application";
-        "public-availability-from-application": "public-availability-from-application";
-    }>>;
-    locators: z.ZodArray<z.ZodObject<{
-        kind: z.ZodLiteral<"utf8-range">;
-        start_byte: z.ZodNumber;
-        end_byte: z.ZodNumber;
-        value_digest: z.ZodString;
-    }, z.core.$strict>>;
-}, z.core.$strict>;
-declare const materialClaimMatchBindingSchema: z.ZodObject<{
-    source_id: z.ZodString;
-    capture_digest: z.ZodString;
-    normalized_object_digest: z.ZodString;
-    adapter_id: z.ZodString;
-    adapter_digest: z.ZodString;
-    proof_kind: z.ZodEnum<{
-        attested: "attested";
-        derived: "derived";
-        editorial: "editorial";
-        observed: "observed";
-    }>;
-    derivation_rule: z.ZodNullable<z.ZodEnum<{
-        "consideration-from-benefits": "consideration-from-benefits";
-        "contact-access-from-first-party-mailto": "contact-access-from-first-party-mailto";
-        "eligibility-composition-from-criteria": "eligibility-composition-from-criteria";
-        "first-party-access-operator": "first-party-access-operator";
-        "form-access-from-first-party-application": "form-access-from-first-party-application";
-        "public-availability-from-application": "public-availability-from-application";
-    }>>;
-    locators: z.ZodArray<z.ZodObject<{
-        kind: z.ZodLiteral<"utf8-range">;
-        start_byte: z.ZodNumber;
-        end_byte: z.ZodNumber;
-        value_digest: z.ZodString;
-    }, z.core.$strict>>;
-    binding_digest: z.ZodString;
-}, z.core.$strict>;
-declare const materialClaimResultCoreSchema: z.ZodObject<{
-    result_contract: z.ZodLiteral<"sourcey.material-claim-result/v1alpha1">;
-    claim_id: z.ZodString;
-    status: z.ZodEnum<{
-        contradicted: "contradicted";
-        supported: "supported";
-        unresolved: "unresolved";
-        unsupported: "unsupported";
-    }>;
-    bindings: z.ZodArray<z.ZodObject<{
-        source_id: z.ZodString;
-        capture_digest: z.ZodString;
-        normalized_object_digest: z.ZodString;
-        adapter_id: z.ZodString;
-        adapter_digest: z.ZodString;
-        proof_kind: z.ZodEnum<{
-            attested: "attested";
-            derived: "derived";
-            editorial: "editorial";
-            observed: "observed";
-        }>;
-        derivation_rule: z.ZodNullable<z.ZodEnum<{
-            "consideration-from-benefits": "consideration-from-benefits";
-            "contact-access-from-first-party-mailto": "contact-access-from-first-party-mailto";
-            "eligibility-composition-from-criteria": "eligibility-composition-from-criteria";
-            "first-party-access-operator": "first-party-access-operator";
-            "form-access-from-first-party-application": "form-access-from-first-party-application";
-            "public-availability-from-application": "public-availability-from-application";
-        }>>;
-        locators: z.ZodArray<z.ZodObject<{
-            kind: z.ZodLiteral<"utf8-range">;
-            start_byte: z.ZodNumber;
-            end_byte: z.ZodNumber;
-            value_digest: z.ZodString;
-        }, z.core.$strict>>;
-        binding_digest: z.ZodString;
-    }, z.core.$strict>>;
-    dependency_result_digests: z.ZodArray<z.ZodString>;
-    residue: z.ZodArray<z.ZodObject<{
-        code: z.ZodString;
-        detail_digest: z.ZodString;
-    }, z.core.$strict>>;
-}, z.core.$strict>;
-export declare const materialClaimResultSchema: z.ZodObject<{
-    result_contract: z.ZodLiteral<"sourcey.material-claim-result/v1alpha1">;
-    claim_id: z.ZodString;
-    status: z.ZodEnum<{
-        contradicted: "contradicted";
-        supported: "supported";
-        unresolved: "unresolved";
-        unsupported: "unsupported";
-    }>;
-    bindings: z.ZodArray<z.ZodObject<{
-        source_id: z.ZodString;
-        capture_digest: z.ZodString;
-        normalized_object_digest: z.ZodString;
-        adapter_id: z.ZodString;
-        adapter_digest: z.ZodString;
-        proof_kind: z.ZodEnum<{
-            attested: "attested";
-            derived: "derived";
-            editorial: "editorial";
-            observed: "observed";
-        }>;
-        derivation_rule: z.ZodNullable<z.ZodEnum<{
-            "consideration-from-benefits": "consideration-from-benefits";
-            "contact-access-from-first-party-mailto": "contact-access-from-first-party-mailto";
-            "eligibility-composition-from-criteria": "eligibility-composition-from-criteria";
-            "first-party-access-operator": "first-party-access-operator";
-            "form-access-from-first-party-application": "form-access-from-first-party-application";
-            "public-availability-from-application": "public-availability-from-application";
-        }>>;
-        locators: z.ZodArray<z.ZodObject<{
-            kind: z.ZodLiteral<"utf8-range">;
-            start_byte: z.ZodNumber;
-            end_byte: z.ZodNumber;
-            value_digest: z.ZodString;
-        }, z.core.$strict>>;
-        binding_digest: z.ZodString;
-    }, z.core.$strict>>;
-    dependency_result_digests: z.ZodArray<z.ZodString>;
-    residue: z.ZodArray<z.ZodObject<{
-        code: z.ZodString;
-        detail_digest: z.ZodString;
-    }, z.core.$strict>>;
-    result_digest: z.ZodString;
-}, z.core.$strict>;
-export type MaterialClaim = z.infer<typeof materialClaimSchema>;
-export type MaterialClaimPlan = z.infer<typeof materialClaimPlanSchema>;
-type MaterialClaimMatchBinding = z.infer<typeof materialClaimMatchBindingSchema>;
-export type MaterialClaimResult = z.infer<typeof materialClaimResultSchema>;
-/** Compile every applicable policy root into exact material leaves. */
-export declare function deriveMaterialClaimPlan(input: {
-    readonly revision: ListingRevision;
-    readonly requirements: readonly CoverageRequirement[];
-    readonly coveragePolicyDigest: Digest;
-}): MaterialClaimPlan;
-export declare function createMaterialClaimMatchBinding(input: z.input<typeof materialClaimMatchBindingCoreSchema>): MaterialClaimMatchBinding;
-export declare function createMaterialClaimResult(input: z.input<typeof materialClaimResultCoreSchema>): MaterialClaimResult;
-export declare function verifyMaterialClaimEvaluation(input: {
-    readonly plan: unknown;
-    readonly results: readonly unknown[];
-}): {
-    readonly plan: MaterialClaimPlan;
-    readonly results: readonly MaterialClaimResult[];
-};
-/** One claim result, content-addressed with every binding it records. */
-export declare function verifyMaterialClaimResult(value: unknown): MaterialClaimResult;
-export {};
-//# sourceMappingURL=material-claims.d.ts.map

package/dist/modules/provenance/src/material-claims.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"material-claims.d.ts","sourceRoot":"","sources":["../../../../modules/provenance/src/material-claims.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,MAAM,EAGZ,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,0CAA0C,CAAC;AACpF,OAAO,EAEL,KAAK,eAAe,EACrB,MAAM,2CAA2C,CAAC;AA8EnD,QAAA,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAAsE,CAAC;AAWhG,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAEzB,CAAC;AAEZ,QAAA,MAAM,mCAAmC;;;;;;;;;;;;;;;;;;;;;;;;;;kBAoBrC,CAAC;AAEL,QAAA,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAE1B,CAAC;AAEZ,QAAA,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBA2C/B,CAAC;AAEL,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAE3B,CAAC;AAEZ,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAChE,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AACxE,KAAK,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,+BAA+B,CAAC,CAAC;AACjF,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAE5E,uEAAuE;AACvE,wBAAgB,uBAAuB,CAAC,KAAK,EAAE;IAC7C,QAAQ,CAAC,QAAQ,EAAE,eAAe,CAAC;IACnC,QAAQ,CAAC,YAAY,EAAE,SAAS,mBAAmB,EAAE,CAAC;IACtD,QAAQ,CAAC,oBAAoB,EAAE,MAAM,CAAC;CACvC,GAAG,iBAAiB,CA4CpB;AAED,wBAAgB,+BAA+B,CAC7C,KAAK,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,mCAAmC,CAAC,GACzD,yBAAyB,CAG3B;AAED,wBAAgB,yBAAyB,CACvC,KAAK,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,6BAA6B,CAAC,GACnD,mBAAmB,CAGrB;AAED,wBAAgB,6BAA6B,CAAC,KAAK,EAAE;IACnD,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IACvB,QAAQ,CAAC,OAAO,EAAE,SAAS,OAAO,EAAE,CAAC;CACtC,GAAG;IAAE,QAAQ,CAAC,IAAI,EAAE,iBAAiB,CAAC;IAAC,QAAQ,CAAC,OAAO,EAAE,SAAS,mBAAmB,EAAE,CAAA;CAAE,CAmEzF;AAED,yEAAyE;AACzE,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,OAAO,GAAG,mBAAmB,CAY7E"}

package/dist/modules/provenance/src/material-claims.js

@@ -1,383 +0,0 @@
-import { compareCanonicalStrings, DIGEST_PATTERN, digest, IDENTIFIER_PATTERN, } from "provenry/primitives";
-import { z } from "zod";
-import { evidenceDerivationRuleSchema, evidenceLocatorSchema, evidenceProofKindSchema, } from "../../../contracts/evidence/src/index.js";
-import { catalogRevisionContracts, } from "../../../contracts/revisions/src/index.js";
-import { ENTITY_ID_PATTERN, OFFER_ID_PATTERN, PROGRAM_ID_PATTERN, } from "../../catalog-primitives/src/index.js";
-import { applicableEvidenceCoverageRequirements, evidenceCoverageCandidateRequirements, valueAtEvidencePointer, } from "./evidence-coverage.js";
-const digestSchema = z.string().regex(DIGEST_PATTERN);
-const identifierSchema = z.string().regex(IDENTIFIER_PATTERN);
-const pointerSchema = z.string().regex(/^\/(?:[^~/]|~0|~1)+(?:\/(?:[^~/]|~0|~1)+)*$/u);
-const materialClaimSemanticTypeSchema = z.enum([
-    "exact_text",
-    "editorial_text",
-    "domain",
-    "url",
-    "taxonomy",
-    "lifecycle_state",
-    "qualifier",
-    "money_amount",
-    "currency",
-    "percentage",
-    "duration",
-    "eligibility_composition",
-    "eligibility_value",
-    "source_authority",
-    "access",
-    "boolean",
-    "number",
-    "composition",
-    "structured_value",
-]);
-const materialClaimSubjectSchema = z.discriminatedUnion("subject_type", [
-    z
-        .object({
-        subject_type: z.literal("entity"),
-        entity_id: z.string().regex(ENTITY_ID_PATTERN),
-        revision_digest: digestSchema,
-    })
-        .strict(),
-    z
-        .object({
-        subject_type: z.literal("program"),
-        entity_id: z.string().regex(ENTITY_ID_PATTERN),
-        program_id: z.string().regex(PROGRAM_ID_PATTERN),
-        revision_digest: digestSchema,
-    })
-        .strict(),
-    z
-        .object({
-        subject_type: z.literal("offer"),
-        entity_id: z.string().regex(ENTITY_ID_PATTERN),
-        program_id: z.string().regex(PROGRAM_ID_PATTERN).optional(),
-        offer_id: z.string().regex(OFFER_ID_PATTERN),
-        revision_digest: digestSchema,
-    })
-        .strict(),
-]);
-const materialClaimCoreSchema = z
-    .object({
-    policy_path: pointerSchema,
-    path: pointerSchema,
-    value_digest: digestSchema,
-    semantic_type: materialClaimSemanticTypeSchema,
-    proof_kinds: z.array(z.enum(["observed", "derived", "editorial", "attested"])).min(1),
-    derivation_rules: z.array(identifierSchema),
-    guidance: z.string().min(1).max(500),
-    depends_on: z.array(digestSchema),
-})
-    .strict();
-const materialClaimSchema = materialClaimCoreSchema.extend({ claim_id: digestSchema }).strict();
-const materialClaimPlanCoreSchema = z
-    .object({
-    plan_contract: z.literal("sourcey.material-claim-plan/v1alpha1"),
-    coverage_policy_digest: digestSchema,
-    subject: materialClaimSubjectSchema,
-    claims: z.array(materialClaimSchema).min(1).max(512),
-})
-    .strict();
-export const materialClaimPlanSchema = materialClaimPlanCoreSchema
-    .extend({ plan_digest: digestSchema })
-    .strict();
-const materialClaimMatchBindingCoreSchema = z
-    .object({
-    source_id: identifierSchema,
-    capture_digest: digestSchema,
-    normalized_object_digest: digestSchema,
-    adapter_id: identifierSchema,
-    adapter_digest: digestSchema,
-    proof_kind: evidenceProofKindSchema,
-    derivation_rule: evidenceDerivationRuleSchema.nullable(),
-    locators: z.array(evidenceLocatorSchema).min(1).max(16),
-})
-    .strict()
-    .superRefine((value, context) => {
-    if ((value.proof_kind === "derived") !== (value.derivation_rule !== null)) {
-        context.addIssue({
-            code: "custom",
-            path: ["derivation_rule"],
-            message: "Exactly a derived material-claim binding requires a derivation rule.",
-        });
-    }
-});
-const materialClaimMatchBindingSchema = materialClaimMatchBindingCoreSchema
-    .extend({ binding_digest: digestSchema })
-    .strict();
-const materialClaimResultCoreSchema = z
-    .object({
-    result_contract: z.literal("sourcey.material-claim-result/v1alpha1"),
-    claim_id: digestSchema,
-    status: z.enum(["supported", "unsupported", "contradicted", "unresolved"]),
-    bindings: z.array(materialClaimMatchBindingSchema).max(32),
-    dependency_result_digests: z.array(digestSchema).max(512),
-    residue: z.array(z
-        .object({
-        code: identifierSchema,
-        detail_digest: digestSchema,
-    })
-        .strict()),
-})
-    .strict()
-    .superRefine((value, context) => {
-    if ((value.status === "supported" || value.status === "contradicted") &&
-        value.bindings.length === 0 &&
-        value.dependency_result_digests.length === 0) {
-        context.addIssue({
-            code: "custom",
-            path: ["bindings"],
-            message: `${value.status} material claims require an exact retained evidence binding.`,
-        });
-    }
-    if (value.status === "supported" && value.residue.length > 0) {
-        context.addIssue({
-            code: "custom",
-            path: ["residue"],
-            message: "A supported material claim cannot retain unresolved residue.",
-        });
-    }
-    if (value.status === "unresolved" && value.residue.length === 0) {
-        context.addIssue({
-            code: "custom",
-            path: ["residue"],
-            message: "An unresolved material claim must explain its typed residue.",
-        });
-    }
-});
-export const materialClaimResultSchema = materialClaimResultCoreSchema
-    .extend({ result_digest: digestSchema })
-    .strict();
-/** Compile every applicable policy root into exact material leaves. */
-export function deriveMaterialClaimPlan(input) {
-    const { revision_digest: revisionDigest, ...revisionCore } = input.revision;
-    if (digest(revisionCore) !== revisionDigest) {
-        throw new Error("Material claim planning requires a content-addressed revision.");
-    }
-    const applicable = applicableEvidenceCoverageRequirements(input.revision.content, input.requirements);
-    const claims = applicable
-        .flatMap((requirement) => {
-        const leafClaims = evidenceCoverageCandidateRequirements(input.revision.content, [
-            requirement,
-        ]).map((candidate) => {
-            const value = valueAtEvidencePointer(input.revision.content, candidate.path);
-            const core = materialClaimCoreSchema.parse({
-                policy_path: requirement.path,
-                path: candidate.path,
-                value_digest: digest(value),
-                semantic_type: classifyMaterialClaim(candidate.path, value, requirement),
-                proof_kinds: candidate.proof_kinds,
-                derivation_rules: candidate.derivation_rules,
-                guidance: candidate.guidance,
-                depends_on: [],
-            });
-            return materialClaimSchema.parse({ ...core, claim_id: digest(core) });
-        });
-        return [...leafClaims, ...compositionClaims(input.revision.content, requirement, leafClaims)];
-    })
-        .sort((left, right) => compareCanonicalStrings(left.path, right.path) ||
-        compareCanonicalStrings(left.claim_id, right.claim_id));
-    if (new Set(claims.map(({ claim_id: claimId }) => claimId)).size !== claims.length) {
-        throw new Error("Material claim policy roots overlap after exact composition expansion.");
-    }
-    const core = materialClaimPlanCoreSchema.parse({
-        plan_contract: "sourcey.material-claim-plan/v1alpha1",
-        coverage_policy_digest: input.coveragePolicyDigest,
-        subject: materialClaimSubject(input.revision),
-        claims,
-    });
-    return materialClaimPlanSchema.parse({ ...core, plan_digest: digest(core) });
-}
-export function createMaterialClaimMatchBinding(input) {
-    const core = materialClaimMatchBindingCoreSchema.parse(input);
-    return materialClaimMatchBindingSchema.parse({ ...core, binding_digest: digest(core) });
-}
-export function createMaterialClaimResult(input) {
-    const core = materialClaimResultCoreSchema.parse(input);
-    return materialClaimResultSchema.parse({ ...core, result_digest: digest(core) });
-}
-export function verifyMaterialClaimEvaluation(input) {
-    const plan = materialClaimPlanSchema.parse(input.plan);
-    const { plan_digest: planDigest, ...planCore } = plan;
-    if (digest(materialClaimPlanCoreSchema.parse(planCore)) !== planDigest) {
-        throw new Error("Material claim plan digest does not match its exact content.");
-    }
-    for (const claim of plan.claims) {
-        const { claim_id: claimId, ...claimCore } = claim;
-        if (digest(materialClaimCoreSchema.parse(claimCore)) !== claimId) {
-            throw new Error(`Material claim ${claimId} is not content-addressed correctly.`);
-        }
-    }
-    const results = input.results.map(verifyMaterialClaimResult);
-    const resultByClaim = new Map(results.map((result) => [result.claim_id, result]));
-    const expected = [...plan.claims.map(({ claim_id: claimId }) => claimId)].sort(compareCanonicalStrings);
-    const actual = [...results.map(({ claim_id: claimId }) => claimId)].sort(compareCanonicalStrings);
-    if (actual.length !== expected.length ||
-        actual.some((claimId, index) => claimId !== expected[index])) {
-        throw new Error("Material claim results do not close the exact claim plan.");
-    }
-    for (const result of results) {
-        const { result_digest: resultDigest } = result;
-        const claim = plan.claims.find(({ claim_id: claimId }) => claimId === result.claim_id);
-        if (!claim)
-            throw new Error(`Material claim result ${resultDigest} names no claim.`);
-        for (const binding of result.bindings) {
-            const { binding_digest: bindingDigest } = binding;
-            if (!claim.proof_kinds.includes(binding.proof_kind) ||
-                (binding.derivation_rule !== null &&
-                    !claim.derivation_rules.includes(binding.derivation_rule))) {
-                throw new Error(`Material claim binding ${bindingDigest} uses proof outside claim ${claim.claim_id}.`);
-            }
-        }
-        const expectedDependencies = claim.depends_on
-            .map((claimId) => resultByClaim.get(claimId)?.result_digest)
-            .filter((candidate) => candidate !== undefined)
-            .sort(compareCanonicalStrings);
-        const actualDependencies = [...result.dependency_result_digests].sort(compareCanonicalStrings);
-        if (expectedDependencies.length !== claim.depends_on.length ||
-            expectedDependencies.length !== actualDependencies.length ||
-            expectedDependencies.some((candidate, index) => candidate !== actualDependencies[index])) {
-            throw new Error(`Material claim result ${resultDigest} has an incomplete dependency closure.`);
-        }
-        if (result.status === "supported" &&
-            claim.depends_on.some((claimId) => resultByClaim.get(claimId)?.status !== "supported")) {
-            throw new Error(`Material claim result ${resultDigest} depends on a non-supported claim.`);
-        }
-    }
-    return {
-        plan,
-        results: [...results].sort((left, right) => compareCanonicalStrings(left.claim_id, right.claim_id)),
-    };
-}
-/** One claim result, content-addressed with every binding it records. */
-export function verifyMaterialClaimResult(value) {
-    const result = materialClaimResultSchema.parse(value);
-    const { result_digest: resultDigest, ...resultCore } = result;
-    if (digest(materialClaimResultCoreSchema.parse(resultCore)) !== resultDigest) {
-        throw new Error(`Material claim result ${resultDigest} is not content-addressed correctly.`);
-    }
-    for (const { binding_digest: bindingDigest, ...bindingCore } of result.bindings) {
-        if (digest(materialClaimMatchBindingCoreSchema.parse(bindingCore)) !== bindingDigest) {
-            throw new Error(`Material claim binding ${bindingDigest} is not content-addressed.`);
-        }
-    }
-    return result;
-}
-function compositionClaims(content, requirement, leaves) {
-    const candidatePaths = new Set();
-    for (const leaf of leaves) {
-        let candidate = parentPointer(leaf.path);
-        while (candidate !== null && pointerWithin(candidate, requirement.path)) {
-            const value = valueAtEvidencePointer(content, candidate);
-            if (typeof value === "object" && value !== null)
-                candidatePaths.add(candidate);
-            if (candidate === requirement.path)
-                break;
-            candidate = parentPointer(candidate);
-        }
-    }
-    const claims = new Map(leaves.map((claim) => [claim.path, claim]));
-    const compositions = [];
-    for (const path of [...candidatePaths].sort((left, right) => pointerDepth(right) - pointerDepth(left))) {
-        const descendants = [...claims.values()].filter((claim) => claim.path.startsWith(`${path}/`) && !hasIntermediateClaim(path, claim.path, claims));
-        const value = valueAtEvidencePointer(content, path);
-        if (!Array.isArray(value) && descendants.length < 2)
-            continue;
-        const dependsOn = descendants
-            .map(({ claim_id: claimId }) => claimId)
-            .sort(compareCanonicalStrings);
-        const core = materialClaimCoreSchema.parse({
-            policy_path: requirement.path,
-            path,
-            value_digest: digest({ composition_path: path, child_claim_ids: dependsOn }),
-            semantic_type: "composition",
-            proof_kinds: requirement.proof_kinds,
-            derivation_rules: requirement.derivation_rules,
-            guidance: requirement.guidance,
-            depends_on: dependsOn,
-        });
-        const claim = materialClaimSchema.parse({ ...core, claim_id: digest(core) });
-        claims.set(path, claim);
-        compositions.push(claim);
-    }
-    return compositions;
-}
-function hasIntermediateClaim(ancestor, descendant, claims) {
-    let candidate = parentPointer(descendant);
-    while (candidate !== null && candidate !== ancestor) {
-        if (claims.has(candidate))
-            return true;
-        candidate = parentPointer(candidate);
-    }
-    return false;
-}
-function parentPointer(path) {
-    const separator = path.lastIndexOf("/");
-    return separator <= 0 ? null : path.slice(0, separator);
-}
-function pointerWithin(candidate, root) {
-    return candidate === root || candidate.startsWith(`${root}/`);
-}
-function pointerDepth(path) {
-    return path.split("/").length - 1;
-}
-function materialClaimSubject(revision) {
-    if (revision.revision_contract === catalogRevisionContracts.entity) {
-        return {
-            subject_type: "entity",
-            entity_id: revision.entity_id,
-            revision_digest: revision.revision_digest,
-        };
-    }
-    if (revision.revision_contract === catalogRevisionContracts.program) {
-        return {
-            subject_type: "program",
-            entity_id: revision.entity_id,
-            program_id: revision.program_id,
-            revision_digest: revision.revision_digest,
-        };
-    }
-    return {
-        subject_type: "offer",
-        entity_id: revision.entity_id,
-        ...(revision.program_id === undefined ? {} : { program_id: revision.program_id }),
-        offer_id: revision.offer_id,
-        revision_digest: revision.revision_digest,
-    };
-}
-function classifyMaterialClaim(path, value, requirement) {
-    if (path === "/category")
-        return "taxonomy";
-    if (path.startsWith("/domains/"))
-        return "domain";
-    if (path.startsWith("/roles/"))
-        return "source_authority";
-    if (path.startsWith("/lifecycle/"))
-        return "lifecycle_state";
-    if (path.startsWith("/access/"))
-        return "access";
-    if (/\/(?:url|terms_url)$/u.test(path) || path.startsWith("/links/"))
-        return "url";
-    if (path.endsWith("/minor_units"))
-        return "money_amount";
-    if (path.endsWith("/currency"))
-        return "currency";
-    if (path.includes("basis_points"))
-        return "percentage";
-    if (path.endsWith("/duration/value"))
-        return "duration";
-    if (path.startsWith("/eligibility/") && path.endsWith("/kind")) {
-        return "eligibility_composition";
-    }
-    if (path.startsWith("/eligibility/"))
-        return "eligibility_value";
-    if (path.endsWith("/kind"))
-        return "qualifier";
-    if (requirement.proof_kinds.includes("editorial"))
-        return "editorial_text";
-    if (typeof value === "string")
-        return "exact_text";
-    if (typeof value === "number")
-        return "number";
-    if (typeof value === "boolean")
-        return "boolean";
-    return "structured_value";
-}
-//# sourceMappingURL=material-claims.js.map