project-tiny-context-harness 0.11.0 → 0.12.0

package/dist/lib/long-task-semantic-fact-contract-closure.js

@@ -1,211 +0,0 @@
-import { validateSemanticFactOutcomeBindings } from "./long-task-semantic-fact-contract-facts.js";
-import { validateSemanticFactProofBindings } from "./long-task-semantic-fact-contract-proofs.js";
-import { globalCompatibleOutcomeApplicabilityCoverage, outcomeApplicabilityPairIdentity, sameApplicabilityProfile, sameOutcomeApplicabilityCoverage, } from "./long-task-applicability-identity.js";
-import { assertSameSemanticFactClosureSet, semanticFactClosureInvalid, uniqueSemanticFactClosureValues, } from "./long-task-semantic-fact-closure-primitives.js";
-export function validateSemanticFactContractProjection(contract, manifest, index, factRevisions, obligationRevisions, sourceRequiresRevisions) {
-    const expectations = new Map();
-    const allFactBindings = [];
-    const allProofBindings = [];
-    const targetByRef = new Map(contract.task.execution_targets.map((item) => [item.key, item]));
-    for (const outcome of contract.outcomes) {
-        const facts = manifest.facts.filter((item) => item.outcome_ref === outcome.key);
-        const proofs = manifest.proof_obligations.filter((proof) => facts.some((fact) => fact.key === proof.fact_ref));
-        const bindings = outcome.semantic_fact_bindings;
-        const revisionsRequired = sourceRequiresRevisions ||
-            bindings.facts.some((item) => item.fact_revision_digest !== undefined) ||
-            bindings.proofs.some((item) => item.obligation_revision_digest !== undefined);
-        assertSameSemanticFactClosureSet(bindings.facts.map((item) => item.fact_ref), facts.map((item) => item.key), `contract_fact_set:${outcome.key}`);
-        if (revisionsRequired) {
-            assertSameSemanticFactClosureSet(bindings.facts.map((item) => revisionPair(item.fact_ref, item.fact_revision_digest, `contract_fact_revision:${outcome.key}`)), facts.map((item) => revisionPair(item.key, factRevisions.get(item.key), `source_fact_revision:${outcome.key}`)), `contract_fact_revision_set:${outcome.key}`);
-            assertSameSemanticFactClosureSet(bindings.proofs.map((item) => revisionPair(item.proof_ref, item.obligation_revision_digest, `contract_obligation_revision:${outcome.key}`)), proofs.map((item) => revisionPair(item.key, obligationRevisions.get(item.key), `source_obligation_revision:${outcome.key}`)), `contract_obligation_revision_set:${outcome.key}`);
-        }
-        assertSameSemanticFactClosureSet(bindings.proofs.map((item) => item.proof_ref), proofs.map((item) => item.key), `contract_proof_set:${outcome.key}`);
-        uniqueSemanticFactClosureValues(bindings.proofs
-            .filter((item) => item.authority === "machine")
-            .map((item) => `${item.check_ref}\0${item.assertion_ref}`), `contract_proof_target:${outcome.key}`);
-        validateSemanticFactOutcomeBindings(outcome, manifest, index, allFactBindings, factRevisions, revisionsRequired);
-        validateSemanticFactProofBindings(contract, outcome, manifest, index, targetByRef, expectations, allProofBindings, factRevisions, obligationRevisions, revisionsRequired);
-    }
-    validateSemanticFactGlobalBindings(contract, manifest, index);
-    assertSameSemanticFactClosureSet(allFactBindings, manifest.facts.map((item) => item.key), "contract_all_fact_set");
-    assertSameSemanticFactClosureSet(allProofBindings, manifest.proof_obligations.map((item) => item.key), "contract_all_proof_set");
-    return expectations;
-}
-function validateSemanticFactGlobalBindings(contract, manifest, index) {
-    const claims = globalMaterialClaims(contract);
-    const bindings = contract.global.semantic_fact_bindings;
-    if (!claims.length) {
-        if (bindings?.obligations.length)
-            semanticFactClosureInvalid("global_semantic_fact_claim_unknown", bindings.obligations[0].claim_ref);
-        return;
-    }
-    if (!bindings)
-        semanticFactClosureInvalid("global_semantic_fact_bindings_required", claims
-            .map((claim) => claim.claim_ref)
-            .sort()
-            .join(","));
-    if (bindings.manifest_ref !== contract.semantic_fact_manifest.key)
-        semanticFactClosureInvalid("global_semantic_fact_manifest_ref_mismatch", `${bindings.manifest_ref}:${contract.semantic_fact_manifest.key}`);
-    const claimsByRef = new Map(claims.map((claim) => [claim.claim_ref, claim]));
-    const applicabilityByRef = new Map(contract.global.applicability.map((item) => [item.key, item]));
-    const validationContext = {
-        contract,
-        index,
-        claims_by_ref: claimsByRef,
-        applicability_by_ref: applicabilityByRef,
-    };
-    validateGlobalObligationRows(bindings.obligations, validationContext);
-    for (const claim of claims)
-        for (const applicabilityRef of claim.applicability_refs)
-            validateGlobalClaimApplicabilityCoverage(contract, manifest, bindings, claim, applicabilityRef, applicabilityByRef);
-}
-function validateGlobalObligationRows(obligations, context) {
-    const tupleKeys = new Set();
-    for (const binding of obligations) {
-        const tupleKey = globalObligationTupleKey(binding);
-        if (tupleKeys.has(tupleKey))
-            semanticFactClosureInvalid("global_semantic_fact_obligation_duplicate", tupleKey.replaceAll("\0", ":"));
-        tupleKeys.add(tupleKey);
-        validateGlobalObligation(binding, context);
-    }
-}
-function globalObligationTupleKey(binding) {
-    return [
-        binding.claim_ref,
-        binding.applicability_ref,
-        binding.target_ref,
-        binding.outcome_ref,
-        binding.fact_ref,
-        binding.proof_ref,
-        binding.method,
-    ].join("\0");
-}
-function validateGlobalObligation(binding, context) {
-    const { contract, index, claims_by_ref, applicability_by_ref } = context;
-    const claim = claims_by_ref.get(binding.claim_ref);
-    if (!claim)
-        semanticFactClosureInvalid("global_semantic_fact_claim_unknown", binding.claim_ref);
-    if (!claim.applicability_refs.includes(binding.applicability_ref))
-        semanticFactClosureInvalid("global_semantic_fact_applicability_not_owned", `${binding.claim_ref}:${binding.applicability_ref}`);
-    if (binding.required_polarity !== claim.required_polarity)
-        semanticFactClosureInvalid("global_semantic_fact_polarity_mismatch", `${binding.claim_ref}:${binding.required_polarity}:${claim.required_polarity}`);
-    const applicability = applicability_by_ref.get(binding.applicability_ref);
-    if (!applicability)
-        semanticFactClosureInvalid("global_semantic_fact_applicability_unknown", `${binding.claim_ref}:${binding.applicability_ref}`);
-    if (binding.target_ref !== applicability.target_ref)
-        semanticFactClosureInvalid("global_semantic_fact_target_mismatch", `${binding.claim_ref}:${binding.applicability_ref}:${binding.target_ref}:${applicability.target_ref}`);
-    const outcome = contract.outcomes.find((item) => item.key === binding.outcome_ref);
-    if (!outcome)
-        semanticFactClosureInvalid("global_semantic_fact_outcome_unknown", `${binding.claim_ref}:${binding.outcome_ref}`);
-    const fact = index.fact_by_ref.get(binding.fact_ref);
-    if (!fact)
-        semanticFactClosureInvalid("global_semantic_fact_unknown", `${binding.claim_ref}:${binding.fact_ref}`);
-    if (fact.outcome_ref !== binding.outcome_ref)
-        semanticFactClosureInvalid("global_semantic_fact_outcome_mismatch", `${binding.fact_ref}:${binding.outcome_ref}:${fact.outcome_ref}`);
-    const factBinding = outcome.semantic_fact_bindings.facts.find((item) => item.fact_ref === binding.fact_ref);
-    if (!factBinding)
-        semanticFactClosureInvalid("global_semantic_fact_outcome_binding_missing", `${binding.claim_ref}:${binding.outcome_ref}:${binding.fact_ref}`);
-    const factApplicability = outcome.applicability.find((item) => item.key === factBinding.applicability_ref);
-    if (!factApplicability || factApplicability.target_ref !== binding.target_ref)
-        semanticFactClosureInvalid("global_semantic_fact_outcome_target_mismatch", `${binding.claim_ref}:${binding.outcome_ref}:${binding.fact_ref}:${binding.target_ref}`);
-    if (!sameApplicabilityProfile(applicability, factApplicability))
-        semanticFactClosureInvalid("global_semantic_fact_applicability_profile_mismatch", `${binding.claim_ref}:${binding.applicability_ref}:${binding.outcome_ref}:${factBinding.applicability_ref}`);
-    const proof = index.proof_by_ref.get(binding.proof_ref);
-    if (!proof)
-        semanticFactClosureInvalid("global_semantic_fact_proof_unknown", `${binding.claim_ref}:${binding.proof_ref}`);
-    if (proof.fact_ref !== binding.fact_ref ||
-        proof.method !== binding.method ||
-        !outcome.semantic_fact_bindings.proofs.some((item) => item.proof_ref === binding.proof_ref &&
-            item.fact_ref === binding.fact_ref &&
-            item.method === binding.method))
-        semanticFactClosureInvalid("global_semantic_fact_proof_identity_mismatch", `${binding.claim_ref}:${binding.fact_ref}:${binding.proof_ref}:${binding.method}`);
-    if (!globalClaimSourceOwners(contract, binding.claim_ref).some((sourceRef) => fact.source_item_refs.includes(sourceRef)))
-        semanticFactClosureInvalid("global_semantic_fact_source_lineage_missing", `${binding.claim_ref}:${binding.fact_ref}`);
-}
-function validateGlobalClaimApplicabilityCoverage(contract, manifest, bindings, claim, applicabilityRef, applicabilityByRef) {
-    const applicability = applicabilityByRef.get(applicabilityRef);
-    if (!applicability)
-        semanticFactClosureInvalid("global_semantic_fact_applicability_unknown", `${claim.claim_ref}:${applicabilityRef}`);
-    const selected = bindings.obligations.filter((item) => item.claim_ref === claim.claim_ref &&
-        item.applicability_ref === applicabilityRef &&
-        item.target_ref === applicability.target_ref);
-    if (!selected.length)
-        semanticFactClosureInvalid("broad_claim_semantic_fact_required", `GLOBAL:${claim.claim_ref}:${applicabilityRef}`);
-    const localCoverage = globalCompatibleOutcomeApplicabilityCoverage(contract, applicability);
-    validateGlobalTargetOutcomeCoverage(claim.claim_ref, applicabilityRef, applicability.target_ref, localCoverage, selected);
-    validateGlobalLocalApplicabilityCoverage(contract, claim.claim_ref, applicabilityRef, localCoverage, selected);
-    validateGlobalFactMethodCoverage(manifest, claim.claim_ref, applicabilityRef, selected);
-}
-function validateGlobalTargetOutcomeCoverage(claimRef, applicabilityRef, targetRef, localCoverage, selected) {
-    const requiredOutcomes = localCoverage.target_outcome_refs;
-    if (!requiredOutcomes.length)
-        semanticFactClosureInvalid("global_semantic_fact_target_unowned", `${claimRef}:${applicabilityRef}:${targetRef}`);
-    if (localCoverage.missing_outcome_refs.length)
-        semanticFactClosureInvalid("global_semantic_fact_outcome_applicability_missing", `${claimRef}:${applicabilityRef}:${localCoverage.missing_outcome_refs.join(",")}`);
-    const coveredOutcomes = [
-        ...new Set(selected.map((item) => item.outcome_ref)),
-    ].sort();
-    if (requiredOutcomes.length !== coveredOutcomes.length ||
-        requiredOutcomes.some((outcomeRef, index) => outcomeRef !== coveredOutcomes[index]))
-        semanticFactClosureInvalid("global_semantic_fact_target_coverage_incomplete", `${claimRef}:${applicabilityRef}:required=${requiredOutcomes.join(",")}:actual=${coveredOutcomes.join(",")}`);
-}
-function validateGlobalLocalApplicabilityCoverage(contract, claimRef, applicabilityRef, localCoverage, selected) {
-    const covered = [
-        ...new Map(selected.map((item) => {
-            const outcome = contract.outcomes.find((candidate) => candidate.key === item.outcome_ref);
-            const factBinding = outcome.semantic_fact_bindings.facts.find((candidate) => candidate.fact_ref === item.fact_ref);
-            const pair = {
-                outcome_ref: item.outcome_ref,
-                applicability_ref: factBinding.applicability_ref,
-            };
-            return [outcomeApplicabilityPairIdentity(pair), pair];
-        })).values(),
-    ];
-    if (!sameOutcomeApplicabilityCoverage(localCoverage.required_pairs, covered))
-        semanticFactClosureInvalid("global_semantic_fact_local_applicability_coverage_incomplete", `${claimRef}:${applicabilityRef}:required=${localCoverage.required_pairs.map(outcomeApplicabilityPairIdentity).join(",")}:actual=${covered.map(outcomeApplicabilityPairIdentity).sort().join(",")}`);
-}
-function validateGlobalFactMethodCoverage(manifest, claimRef, applicabilityRef, selected) {
-    for (const factRef of new Set(selected.map((item) => item.fact_ref))) {
-        const requiredProofs = manifest.proof_obligations
-            .filter((proof) => proof.fact_ref === factRef)
-            .map((proof) => `${proof.key}\0${proof.method}`)
-            .sort();
-        const boundProofs = selected
-            .filter((item) => item.fact_ref === factRef)
-            .map((item) => `${item.proof_ref}\0${item.method}`)
-            .sort();
-        if (requiredProofs.length !== boundProofs.length ||
-            requiredProofs.some((proofIdentity, index) => proofIdentity !== boundProofs[index]))
-            semanticFactClosureInvalid("global_semantic_fact_method_coverage_incomplete", `${claimRef}:${applicabilityRef}:${factRef}`);
-    }
-}
-function globalMaterialClaims(contract) {
-    return [
-        ...contract.global.product.non_goals.map((item) => ({
-            claim_ref: `non_goal.${item.key}`,
-            applicability_refs: item.applicability_refs,
-            required_polarity: "negative",
-        })),
-        ...contract.global.technical.constraints.map((item) => ({
-            claim_ref: `constraint.${item.key}`,
-            applicability_refs: item.applicability_refs,
-            required_polarity: "positive",
-        })),
-        ...contract.global.technical.forbidden_shortcuts.map((item) => ({
-            claim_ref: `forbidden_shortcut.${item.key}`,
-            applicability_refs: item.applicability_refs,
-            required_polarity: "negative",
-        })),
-    ];
-}
-function globalClaimSourceOwners(contract, claimRef) {
-    return contract.source_claims
-        .filter((source) => source.disposition.type === "global_constraint" &&
-        source.disposition.refs.includes(claimRef))
-        .map((source) => source.key);
-}
-function revisionPair(key, digest, label) {
-    if (!digest)
-        throw new Error(`semantic_fact_closure_invalid:${label}:${key}:missing`);
-    return `${key}\0${digest}`;
-}

package/dist/lib/long-task-semantic-fact-contract-facts.d.ts

@@ -1,4 +0,0 @@
-import type { DeliveryContractV2 } from "./long-task-delivery-types.js";
-import type { SemanticFactManifestIndexV1 } from "./semantic-fact-policy.js";
-import type { SemanticFactManifestV1 } from "./semantic-fact-types.js";
-export declare function validateSemanticFactOutcomeBindings(outcome: DeliveryContractV2["outcomes"][number], manifest: SemanticFactManifestV1, index: SemanticFactManifestIndexV1, allFactBindings: string[], factRevisions: Map<string, string>, revisionsRequired: boolean): void;

package/dist/lib/long-task-semantic-fact-contract-facts.js

@@ -1,33 +0,0 @@
-import { semanticFactClosureInvalid, uniqueSemanticFactClosureValues, } from "./long-task-semantic-fact-closure-primitives.js";
-export function validateSemanticFactOutcomeBindings(outcome, manifest, index, allFactBindings, factRevisions, revisionsRequired) {
-    uniqueSemanticFactClosureValues(outcome.semantic_fact_bindings.facts.map((item) => item.claim_ref), `contract_fact_claim:${outcome.key}`);
-    const applicabilityRefs = new Set(outcome.applicability.map((item) => item.key));
-    for (const binding of outcome.semantic_fact_bindings.facts) {
-        const fact = index.fact_by_ref.get(binding.fact_ref);
-        const expectedClaim = `semantic_fact.${binding.fact_ref}`;
-        if (revisionsRequired &&
-            binding.fact_revision_digest !== factRevisions.get(binding.fact_ref))
-            semanticFactClosureInvalid("contract_fact_revision_mismatch", `${outcome.key}:${binding.fact_ref}:${binding.fact_revision_digest ?? "missing"}:${factRevisions.get(binding.fact_ref) ?? "missing"}`);
-        if (binding.claim_ref !== expectedClaim)
-            semanticFactClosureInvalid("contract_fact_claim_identity_mismatch", `${outcome.key}:${binding.fact_ref}:${binding.claim_ref}:${expectedClaim}`);
-        if (!applicabilityRefs.has(binding.applicability_ref))
-            semanticFactClosureInvalid("contract_fact_applicability_unknown", `${outcome.key}:${binding.fact_ref}:${binding.applicability_ref}`);
-        validateSemanticFactApplicabilityProjection(manifest, fact, outcome.applicability.find((item) => item.key === binding.applicability_ref));
-        if (fact.outcome_ref !== outcome.key)
-            semanticFactClosureInvalid("contract_fact_outcome_mismatch", `${outcome.key}:${binding.fact_ref}`);
-        allFactBindings.push(binding.fact_ref);
-    }
-}
-function validateSemanticFactApplicabilityProjection(manifest, fact, applicability) {
-    const condition = manifest.conditions.find((item) => item.key === fact.condition_ref);
-    if (!condition)
-        semanticFactClosureInvalid("contract_fact_condition_unknown", `${fact.key}:${fact.condition_ref}`);
-    for (const assignment of condition.axis_values) {
-        const axis = manifest.axis_dispositions.find((item) => item.key === assignment.axis_ref);
-        if (!axis)
-            semanticFactClosureInvalid("contract_fact_condition_axis_unknown", `${fact.key}:${assignment.axis_ref}`);
-        if (!applicability.dimensions.some((dimension) => dimension.key === axis.axis &&
-            dimension.value === assignment.value_ref))
-            semanticFactClosureInvalid("contract_fact_applicability_condition_mismatch", `${fact.key}:${applicability.key}:${axis.axis}:${assignment.value_ref}`);
-    }
-}

package/dist/lib/long-task-semantic-fact-contract-proofs.d.ts

@@ -1,4 +0,0 @@
-import type { DeliveryContractV2, ExecutionTargetV2 } from "./long-task-delivery-types.js";
-import type { SemanticFactManifestIndexV1 } from "./semantic-fact-policy.js";
-import type { SemanticFactExpectationV2, SemanticFactManifestV1 } from "./semantic-fact-types.js";
-export declare function validateSemanticFactProofBindings(contract: DeliveryContractV2, outcome: DeliveryContractV2["outcomes"][number], manifest: SemanticFactManifestV1, index: SemanticFactManifestIndexV1, targetByRef: Map<string, ExecutionTargetV2>, expectations: Map<string, SemanticFactExpectationV2[]>, allProofBindings: string[], factRevisions: Map<string, string>, obligationRevisions: Map<string, string>, revisionsRequired: boolean): void;

package/dist/lib/long-task-semantic-fact-contract-proofs.js

@@ -1,123 +0,0 @@
-import { sameSemanticFactClosureSet, semanticFactClosureInvalid, } from "./long-task-semantic-fact-closure-primitives.js";
-export function validateSemanticFactProofBindings(contract, outcome, manifest, index, targetByRef, expectations, allProofBindings, factRevisions, obligationRevisions, revisionsRequired) {
-    for (const binding of outcome.semantic_fact_bindings.proofs) {
-        const proof = index.proof_by_ref.get(binding.proof_ref);
-        const factBinding = outcome.semantic_fact_bindings.facts.find((item) => item.fact_ref === binding.fact_ref);
-        if (!factBinding)
-            semanticFactClosureInvalid("contract_proof_fact_binding_missing", `${outcome.key}:${binding.proof_ref}:${binding.fact_ref}`);
-        if (revisionsRequired &&
-            binding.obligation_revision_digest !==
-                obligationRevisions.get(binding.proof_ref))
-            semanticFactClosureInvalid("contract_obligation_revision_mismatch", `${outcome.key}:${binding.proof_ref}:${binding.obligation_revision_digest ?? "missing"}:${obligationRevisions.get(binding.proof_ref) ?? "missing"}`);
-        validateProofIdentity(outcome, proof, binding);
-        validateObserverTargets(proof, binding, targetByRef);
-        if (binding.authority === "external_confirmation")
-            validateExternalProofProjection(contract, outcome, binding, factBinding.claim_ref);
-        else
-            validateMachineProofProjection(contract, outcome, manifest, index, binding, proof, factBinding, expectations, factRevisions, obligationRevisions, revisionsRequired);
-        allProofBindings.push(binding.proof_ref);
-    }
-}
-function validateProofIdentity(outcome, proof, binding) {
-    if (proof.fact_ref !== binding.fact_ref ||
-        proof.method !== binding.method ||
-        proof.proof_surface !== binding.proof_surface ||
-        proof.authority !== binding.authority ||
-        !sameSemanticFactClosureSet(proof.evidence_capabilities, binding.evidence_capabilities))
-        semanticFactClosureInvalid("contract_proof_identity_mismatch", `${outcome.key}:${binding.proof_ref}`);
-}
-function validateObserverTargets(proof, binding, targetByRef) {
-    for (const observerRef of proof.observer_refs)
-        if (!targetByRef.has(observerRef))
-            semanticFactClosureInvalid("proof_observer_target_unknown", `${binding.proof_ref}:${observerRef}`);
-        else if (targetByRef.get(observerRef).role !== "observer")
-            semanticFactClosureInvalid("proof_observer_target_role_mismatch", `${binding.proof_ref}:${observerRef}:${targetByRef.get(observerRef).role}`);
-}
-function validateExternalProofProjection(contract, outcome, binding, claimRef) {
-    const confirmation = contract.global.acceptance.external_confirmations.find((item) => item.key === binding.confirmation_ref);
-    const fullClaim = `${outcome.key}.${claimRef}`;
-    if (!confirmation)
-        semanticFactClosureInvalid("semantic_fact_confirmation_unknown", `${binding.proof_ref}:${binding.confirmation_ref}`);
-    if (!confirmation.impact_claims.includes(fullClaim))
-        semanticFactClosureInvalid("semantic_fact_confirmation_lineage_missing", `${binding.confirmation_ref}:${fullClaim}`);
-}
-function validateMachineProofProjection(contract, outcome, manifest, index, binding, proof, factBinding, expectations, factRevisions, obligationRevisions, revisionsRequired) {
-    const check = outcome.acceptance.checks.find((item) => item.key === binding.check_ref);
-    if (!check)
-        semanticFactClosureInvalid("semantic_fact_check_unknown", `${outcome.key}:${binding.check_ref}`);
-    for (const observerRef of proof.observer_refs)
-        if (observerRef === check.execution_target.target_ref)
-            semanticFactClosureInvalid("proof_observer_not_independent", `${binding.proof_ref}:${observerRef}`);
-    if (check.proof_surface !== binding.proof_surface)
-        semanticFactClosureInvalid("semantic_fact_check_surface_mismatch", `${binding.proof_ref}:${check.proof_surface}:${binding.proof_surface}`);
-    const assertion = check.positive_assertions.find((item) => item.key === binding.assertion_ref);
-    if (!assertion)
-        semanticFactClosureInvalid("semantic_fact_assertion_unknown", `${binding.check_ref}:${binding.assertion_ref}`);
-    if (assertion.claims.length !== 1 ||
-        assertion.claims[0] !== factBinding.claim_ref ||
-        assertion.applicability_ref !== factBinding.applicability_ref ||
-        assertion.operator !== "equals" ||
-        assertion.expected !== true ||
-        !sameSemanticFactClosureSet(assertion.evidence_capabilities, binding.evidence_capabilities))
-        semanticFactClosureInvalid("semantic_fact_assertion_binding_mismatch", {
-            check_ref: binding.check_ref,
-            assertion_ref: binding.assertion_ref,
-            expected: {
-                claims: [factBinding.claim_ref],
-                applicability_ref: factBinding.applicability_ref,
-                operator: "equals",
-                expected: true,
-                evidence_capabilities: [...binding.evidence_capabilities].sort(),
-            },
-            actual: {
-                claims: assertion.claims,
-                applicability_ref: assertion.applicability_ref ?? null,
-                operator: assertion.operator,
-                expected: "expected" in assertion ? assertion.expected : null,
-                evidence_capabilities: [...assertion.evidence_capabilities].sort(),
-            },
-        });
-    validateSemanticFactCounterfactualProjection(outcome, proof, factBinding.claim_ref, binding.check_ref, binding.assertion_ref);
-    const fact = index.fact_by_ref.get(binding.fact_ref);
-    const rows = expectations.get(binding.check_ref) ?? [];
-    rows.push({
-        manifest_ref: manifest.key,
-        manifest_sha256: contract.semantic_fact_manifest.sha256,
-        fact_key: fact.key,
-        fact_revision_digest: factRevisions.get(fact.key),
-        obligation_key: proof.key,
-        obligation_revision_digest: obligationRevisions.get(proof.key),
-        revision_identity_required: revisionsRequired,
-        fact_ref: fact.key,
-        proof_ref: proof.key,
-        method: proof.method,
-        check_ref: binding.check_ref,
-        assertion_ref: binding.assertion_ref,
-        outcome_ref: outcome.key,
-        claim_ref: factBinding.claim_ref,
-        applicability_ref: factBinding.applicability_ref,
-        subject_ref: fact.unit_ref,
-        condition_ref: fact.condition_ref,
-        property_ref: fact.property_ref,
-        observation_sensitivity: fact.observation_sensitivity,
-        expected: fact.expected,
-        comparison: proof.comparison,
-        oracle: index.oracle_by_ref.get(proof.oracle_ref),
-        environment: index.environment_by_ref.get(proof.environment_ref),
-        observer_refs: proof.observer_refs,
-    });
-    expectations.set(binding.check_ref, rows);
-}
-function validateSemanticFactCounterfactualProjection(outcome, proof, claimRef, checkRef, assertionRef) {
-    if (proof.counterfactual.disposition !== "required")
-        return;
-    for (const counterfactualRef of proof.counterfactual.refs) {
-        const counterfactual = outcome.acceptance.counterfactual_controls.find((item) => item.key === counterfactualRef);
-        if (!counterfactual)
-            semanticFactClosureInvalid("semantic_fact_counterfactual_unknown", `${proof.key}:${counterfactualRef}`);
-        if (counterfactual.check_key !== checkRef ||
-            !counterfactual.claims.includes(claimRef) ||
-            !counterfactual.expected_assertion_failures.includes(assertionRef))
-            semanticFactClosureInvalid("semantic_fact_counterfactual_binding_mismatch", `${proof.key}:${counterfactualRef}`);
-    }
-}

package/dist/lib/long-task-semantic-fact-evidence.d.ts

@@ -1,25 +0,0 @@
-import type { CompiledCheckV2, EvidenceCapabilityRecordV2 } from "./long-task-delivery-types.js";
-type SemanticRecord = Extract<EvidenceCapabilityRecordV2, {
-    capability: "semantic_fact";
-}>;
-export declare function validateSemanticFactEvidence(check: CompiledCheckV2, record: SemanticRecord, artifactHashes: Record<string, string>): string | null;
-type SemanticFactExactComparisonMaterial = {
-    fact_ref: string;
-    proof_ref: string;
-    fact_key?: string;
-    fact_revision_digest?: string;
-    obligation_key?: string;
-    obligation_revision_digest?: string;
-    target_ref: string;
-    actual_value_sha256: string;
-    expected_value_sha256: string;
-    comparator: string;
-    mode: "exact" | "tolerance";
-    parameters_sha256: string;
-    tolerance_sha256: string | null;
-    mask_sha256: string | null;
-};
-export declare function semanticFactComparisonResultIdentity(value: SemanticFactExactComparisonMaterial): string;
-export declare function validateDistinctSemanticFactEvidence(records: EvidenceCapabilityRecordV2[]): string | null;
-export declare const typed_semantic_fact_runtime_evidence = "obligation_key+obligation_revision_digest->fact_key+fact_revision_digest+actual+comparison+verdict+oracle+environment";
-export {};

package/dist/lib/long-task-semantic-fact-evidence.js

@@ -1,225 +0,0 @@
-import { evaluateExactDigestComparison, } from "./long-task-exact-comparison.js";
-import { canonicalValueJson } from "./strict-codec.js";
-export function validateSemanticFactEvidence(check, record, artifactHashes) {
-    const expectations = check.semantic_fact_expectations.filter((item) => item.assertion_ref === record.assertion_key);
-    if (expectations.length !== 1)
-        return expectations.length
-            ? "semantic_fact_expectation_duplicate"
-            : "semantic_fact_expectation_missing";
-    const expected = expectations[0];
-    const authorityError = validateSemanticFactEvidenceAuthority(check, record, expected);
-    if (authorityError)
-        return authorityError;
-    const artifactError = validateSemanticFactArtifacts(record, expected, artifactHashes);
-    if (artifactError)
-        return artifactError;
-    const observerError = validateSemanticFactObservers(record, expected, artifactHashes);
-    if (observerError)
-        return observerError;
-    return null;
-}
-function validateSemanticFactEvidenceAuthority(check, record, expected) {
-    if (!sameSemanticFactIdentity(record, expected))
-        return "semantic_fact_identity_mismatch";
-    if (record.target_ref !== check.execution_target.target_ref ||
-        expected.check_ref !== check.key)
-        return "semantic_fact_target_mismatch";
-    if (record.actual_observation.sensitivity !== expected.observation_sensitivity)
-        return "semantic_fact_sensitivity_mismatch";
-    if (!validSemanticFactRedaction(record.actual_observation.sensitivity, record.actual_observation.redaction))
-        return "semantic_fact_redaction_mismatch";
-    if (canonicalValueJson(record.expected) !==
-        canonicalValueJson(expected.expected))
-        return "semantic_fact_expected_value_mismatch";
-    if (!sameSemanticFactComparisonAuthority(record, expected))
-        return "semantic_fact_comparison_authority_mismatch";
-    const exactError = validateSemanticFactExactComparison(record, expected);
-    if (exactError)
-        return exactError;
-    if (canonicalValueJson(record.oracle) !== canonicalValueJson(expected.oracle) ||
-        canonicalValueJson(record.environment) !==
-            canonicalValueJson(expected.environment))
-        return "semantic_fact_oracle_environment_mismatch";
-    return null;
-}
-function sameSemanticFactIdentity(record, expected) {
-    return (record.manifest_ref === expected.manifest_ref &&
-        record.manifest_sha256 === expected.manifest_sha256 &&
-        record.outcome_ref === expected.outcome_ref &&
-        record.fact_ref === expected.fact_ref &&
-        record.proof_ref === expected.proof_ref &&
-        record.method === expected.method &&
-        record.subject_ref === expected.subject_ref &&
-        record.condition_ref === expected.condition_ref &&
-        record.property_ref === expected.property_ref &&
-        sameSemanticFactRevisionIdentity(record, expected));
-}
-function sameSemanticFactRevisionIdentity(record, expected) {
-    const present = record.fact_key !== undefined ||
-        record.fact_revision_digest !== undefined ||
-        record.obligation_key !== undefined ||
-        record.obligation_revision_digest !== undefined;
-    if (!expected.revision_identity_required && !present)
-        return true;
-    return (record.fact_key === expected.fact_key &&
-        record.fact_key === record.fact_ref &&
-        record.fact_revision_digest === expected.fact_revision_digest &&
-        record.obligation_key === expected.obligation_key &&
-        record.obligation_key === record.proof_ref &&
-        record.obligation_revision_digest === expected.obligation_revision_digest);
-}
-function validSemanticFactRedaction(sensitivity, redaction) {
-    return ((sensitivity === "plain" && redaction === null) ||
-        (sensitivity === "protected" && redaction !== null));
-}
-function sameSemanticFactComparisonAuthority(record, expected) {
-    return (expected.comparison.comparator === "exact_value" &&
-        expected.comparison.mode === "exact" &&
-        expected.comparison.tolerance === null &&
-        expected.comparison.mask === null &&
-        record.comparison.comparator === expected.comparison.comparator &&
-        record.comparison.mode === expected.comparison.mode &&
-        canonicalValueJson(record.comparison.parameters) ===
-            canonicalValueJson(expected.comparison.parameters) &&
-        canonicalValueJson(record.comparison.tolerance) ===
-            canonicalValueJson(expected.comparison.tolerance) &&
-        canonicalValueJson(record.comparison.mask) ===
-            canonicalValueJson(expected.comparison.mask));
-}
-function validateSemanticFactExactComparison(record, expected) {
-    const recomputed = evaluateSemanticFactExactComparison(expected, record.target_ref, record.actual_observation.value_sha256);
-    if (!recomputed.passed)
-        return "semantic_fact_exact_value_mismatch";
-    if (record.comparison.passed !== recomputed.passed ||
-        record.verdict !== semanticFactVerdict(recomputed.passed))
-        return "project_submitted_verdict_disagrees_with_harness";
-    return record.comparison.result_sha256 === recomputed.result_sha256
-        ? null
-        : "semantic_fact_comparison_result_identity_mismatch";
-}
-function validateSemanticFactArtifacts(record, expected, artifactHashes) {
-    if (artifactHashes[record.actual_observation.artifact_path] !==
-        record.actual_observation.artifact_sha256)
-        return "semantic_fact_observation_artifact_mismatch";
-    if (artifactHashes[record.actual_environment.artifact_path] !==
-        record.actual_environment.artifact_sha256 ||
-        record.actual_environment.value_sha256 !==
-            expected.environment.definition.sha256)
-        return "semantic_fact_environment_observation_mismatch";
-    if (artifactHashes[record.comparison.artifact_path] !==
-        record.comparison.artifact_sha256)
-        return "semantic_fact_comparison_artifact_mismatch";
-    return null;
-}
-function validateSemanticFactObservers(record, expected, artifactHashes) {
-    if (!sameSet(record.observer_results.map((item) => item.target_ref), expected.observer_refs))
-        return "semantic_fact_observer_set_mismatch";
-    const observerObservations = new Set();
-    const primaryObservation = `${record.actual_observation.artifact_path}\0${canonicalValueJson(record.actual_observation.locator)}`;
-    for (const observer of record.observer_results) {
-        const observation = `${observer.artifact_path}\0${canonicalValueJson(observer.locator)}`;
-        if (observation === primaryObservation ||
-            observerObservations.has(observation))
-            return "semantic_fact_observer_observation_reused";
-        observerObservations.add(observation);
-        if (artifactHashes[observer.artifact_path] !== observer.artifact_sha256)
-            return "semantic_fact_observer_artifact_mismatch";
-        const recomputed = evaluateSemanticFactExactComparison(expected, observer.target_ref, observer.value_sha256);
-        if (!recomputed.passed)
-            return "semantic_fact_observer_failed";
-        if (observer.passed !== recomputed.passed)
-            return "project_submitted_verdict_disagrees_with_harness";
-        if (observer.comparison_result_sha256 !== recomputed.result_sha256)
-            return "semantic_fact_observer_comparison_identity_mismatch";
-    }
-    return null;
-}
-export function semanticFactComparisonResultIdentity(value) {
-    return evaluateSemanticFactExactComparisonMaterial(value).result_sha256;
-}
-function evaluateSemanticFactExactComparison(expected, targetRef, actualValueSha256) {
-    return evaluateSemanticFactExactComparisonMaterial({
-        fact_ref: expected.fact_ref,
-        proof_ref: expected.proof_ref,
-        fact_key: expected.fact_key,
-        fact_revision_digest: expected.fact_revision_digest,
-        obligation_key: expected.obligation_key,
-        obligation_revision_digest: expected.obligation_revision_digest,
-        target_ref: targetRef,
-        actual_value_sha256: actualValueSha256,
-        expected_value_sha256: expected.expected.sha256,
-        comparator: expected.comparison.comparator,
-        mode: expected.comparison.mode,
-        parameters_sha256: expected.comparison.parameters.sha256,
-        tolerance_sha256: expected.comparison.tolerance?.sha256 ?? null,
-        mask_sha256: expected.comparison.mask?.sha256 ?? null,
-    });
-}
-function evaluateSemanticFactExactComparisonMaterial(value) {
-    return evaluateExactDigestComparison({
-        identity: semanticFactComparisonIdentity(value),
-        actual_value_sha256: value.actual_value_sha256,
-        expected_value_sha256: value.expected_value_sha256,
-        comparator: value.comparator,
-        mode: value.mode,
-        parameters_sha256: value.parameters_sha256,
-        tolerance_sha256: value.tolerance_sha256,
-        mask_sha256: value.mask_sha256,
-    });
-}
-function semanticFactComparisonIdentity(value) {
-    const revisionIdentityPresent = value.fact_key !== undefined ||
-        value.fact_revision_digest !== undefined ||
-        value.obligation_key !== undefined ||
-        value.obligation_revision_digest !== undefined;
-    return revisionIdentityPresent
-        ? {
-            kind: "semantic_fact_non_ui",
-            fact_ref: value.fact_ref,
-            proof_ref: value.proof_ref,
-            fact_key: value.fact_key,
-            fact_revision_digest: value.fact_revision_digest,
-            obligation_key: value.obligation_key,
-            obligation_revision_digest: value.obligation_revision_digest,
-            target_ref: value.target_ref,
-        }
-        : {
-            kind: "semantic_fact_non_ui",
-            fact_ref: value.fact_ref,
-            proof_ref: value.proof_ref,
-            target_ref: value.target_ref,
-        };
-}
-function semanticFactVerdict(passed) {
-    return passed ? "passed" : "failed";
-}
-export function validateDistinctSemanticFactEvidence(records) {
-    const observations = new Set();
-    const comparisons = new Set();
-    const identities = new Set();
-    for (const record of records) {
-        if (record.capability !== "semantic_fact")
-            continue;
-        const identity = record.obligation_key
-            ? `${record.obligation_key}\0${record.obligation_revision_digest}\0${record.fact_key}\0${record.fact_revision_digest}`
-            : `${record.fact_ref}\0${record.proof_ref}`;
-        if (identities.has(identity))
-            return "semantic_fact_result_duplicate";
-        identities.add(identity);
-        const observation = `${record.actual_observation.artifact_path}\0${canonicalValueJson(record.actual_observation.locator)}`;
-        if (observations.has(observation))
-            return "semantic_fact_observation_reused";
-        observations.add(observation);
-        const comparison = `${record.comparison.artifact_path}\0${canonicalValueJson(record.comparison.locator)}`;
-        if (comparisons.has(comparison))
-            return "semantic_fact_comparison_reused";
-        comparisons.add(comparison);
-    }
-    return null;
-}
-function sameSet(left, right) {
-    return (left.length === right.length &&
-        new Set(left).size === left.length &&
-        left.every((item) => right.includes(item)));
-}
-export const typed_semantic_fact_runtime_evidence = "obligation_key+obligation_revision_digest->fact_key+fact_revision_digest+actual+comparison+verdict+oracle+environment";

package/dist/lib/long-task-semantic-fact-input-closure.d.ts

@@ -1,18 +0,0 @@
-import type { CompiledSourceItemV2, MaterialTextInputV2 } from "./long-task-source-authority-types.js";
-import type { LongTaskDesignHandoffPreflight } from "./long-task-design-resource-handoff.js";
-import type { SemanticFactManifestV1 } from "./semantic-fact-types.js";
-import type { CapturedContextGraphSnapshot } from "./context-graph-snapshot.js";
-export interface DesignOwnedSemanticFactProjectionV1 {
-    key: string;
-    source_item_refs: string[];
-    basis_refs: string[];
-    expected_search_text: string;
-}
-export interface DesignOwnedSemanticProjectionV1 {
-    source_items: Set<string>;
-    facts: DesignOwnedSemanticFactProjectionV1[];
-}
-export declare function designOwnedSemanticFactProjectionKey(kind: "fact" | "fact_rule", handoffPath: string, factKey: string): string;
-export declare function projectDesignOwnedSemanticFacts(preflights: LongTaskDesignHandoffPreflight[]): DesignOwnedSemanticProjectionV1;
-export declare function collectDesignOwnedSemanticFactSourceItems(repository: string, sourcePaths: string[]): Promise<Set<string>>;
-export declare function validateSemanticFactInputInventory(repository: string, sourceItems: CompiledSourceItemV2[], context: CapturedContextGraphSnapshot, manifest: SemanticFactManifestV1, designProjection: DesignOwnedSemanticProjectionV1): Promise<MaterialTextInputV2[]>;