project-tiny-context-harness 0.8.3 → 0.8.5

package/dist/lib/semantic-fact-policy-primitives.js

@@ -0,0 +1,169 @@
+import { canonicalValueJson, sha256Hex } from "./strict-codec.js";
+export function validateSemanticFactLocatedValue(manifest, located, label) {
+    validateSemanticFactLocator(manifest, located.locator, label);
+    if (located.representation === "inline") {
+        const digest = sha256Hex(canonicalValueJson(located.value));
+        if (digest !== located.sha256)
+            semanticFactInvalid("inline_value_digest_mismatch", `${label}:${located.sha256}:${digest}`);
+    }
+}
+export function validateSemanticFactLocator(manifest, locator, label) {
+    const inputRefs = new Set(manifest.inputs.map((item) => item.key));
+    if (locator.kind === "manifest_pointer"
+        ? locator.material_ref !== manifest.key
+        : !inputRefs.has(locator.material_ref))
+        semanticFactInvalid("locator_material_unknown", `${label}:${locator.material_ref}`);
+}
+export function validateSemanticFactQuantifier(manifest, fact) {
+    const quantifier = fact.quantifier;
+    const population = quantifier.population_ref
+        ? (manifest.populations.find((item) => item.key === quantifier.population_ref) ?? null)
+        : null;
+    validateSemanticFactQuantifierPopulation(fact, population);
+    validateSemanticFactQuantifierNonnegativeBounds(fact);
+    validateSemanticFactQuantifierKindBounds(fact);
+}
+function validateSemanticFactQuantifierPopulation(fact, population) {
+    const quantifier = fact.quantifier;
+    if (quantifier.population_ref && !population)
+        semanticFactInvalid("quantifier_population_unknown", `${fact.key}:${quantifier.population_ref}`);
+    const populationKinds = new Set([
+        "all",
+        "any",
+        "none",
+        "exactly",
+        "at_least",
+        "at_most",
+        "range",
+    ]);
+    if (populationKinds.has(quantifier.kind) && !quantifier.population_ref)
+        semanticFactInvalid("quantifier_population_required", fact.key);
+    if (population && population.outcome_ref !== fact.outcome_ref)
+        semanticFactInvalid("quantifier_population_outcome_mismatch", `${fact.key}:${population.key}`);
+    if (quantifier.kind === "one" && quantifier.population_ref)
+        semanticFactInvalid("quantifier_population_forbidden", fact.key);
+}
+function validateSemanticFactQuantifierNonnegativeBounds(fact) {
+    for (const [label, value] of [
+        ["minimum", fact.quantifier.minimum],
+        ["maximum", fact.quantifier.maximum],
+    ])
+        if (value !== null && (!Number.isInteger(value) || value < 0))
+            semanticFactInvalid(`quantifier_${label}_invalid`, fact.key);
+}
+function validateSemanticFactQuantifierKindBounds(fact) {
+    const quantifier = fact.quantifier;
+    if (quantifier.kind === "exactly" &&
+        (quantifier.minimum === null ||
+            quantifier.maximum === null ||
+            quantifier.minimum !== quantifier.maximum))
+        semanticFactInvalid("quantifier_exactly_bounds_invalid", fact.key);
+    if (quantifier.kind === "at_least" && quantifier.minimum === null)
+        semanticFactInvalid("quantifier_minimum_required", fact.key);
+    if (quantifier.kind === "at_most" && quantifier.maximum === null)
+        semanticFactInvalid("quantifier_maximum_required", fact.key);
+    if (quantifier.kind === "range" &&
+        (quantifier.minimum === null ||
+            quantifier.maximum === null ||
+            quantifier.minimum > quantifier.maximum))
+        semanticFactInvalid("quantifier_range_invalid", fact.key);
+    if (["one", "all", "any", "none"].includes(quantifier.kind) &&
+        (quantifier.minimum !== null || quantifier.maximum !== null))
+        semanticFactInvalid("quantifier_bounds_forbidden", fact.key);
+    if (quantifier.kind === "at_least" && quantifier.maximum !== null)
+        semanticFactInvalid("quantifier_maximum_forbidden", fact.key);
+    if (quantifier.kind === "at_most" && quantifier.minimum !== null)
+        semanticFactInvalid("quantifier_minimum_forbidden", fact.key);
+}
+export function validateSemanticFactCrossProduct(rule, axes, conditions, exclusions) {
+    const values = rule.axis_refs.map((axisRef) => {
+        const axis = axes.get(axisRef);
+        if (!axis)
+            semanticFactInvalid("condition_rule_axis_unknown", `${rule.key}:${axisRef}`);
+        return axis.values.map((item) => `${axisRef}=${item.key}`);
+    });
+    const expected = semanticFactCartesian(values).map((row) => row.sort().join("|"));
+    const actual = [...rule.condition_refs, ...rule.exclusion_refs].map((ref) => {
+        const row = conditions.get(ref) ?? exclusions.get(ref);
+        if (!row)
+            semanticFactInvalid("condition_rule_cell_unknown", `${rule.key}:${ref}`);
+        return row.axis_values
+            .filter((item) => rule.axis_refs.includes(item.axis_ref))
+            .map((item) => `${item.axis_ref}=${item.value_ref}`)
+            .sort()
+            .join("|");
+    });
+    assertSameSemanticFactSet(actual, expected, `condition_rule_cross_product:${rule.key}`);
+}
+export function semanticFactCollections(manifest) {
+    return {
+        inputs: manifest.inputs,
+        inspector_census: manifest.inspector.census,
+        family_dispositions: manifest.family_dispositions,
+        subjects: manifest.subjects,
+        relations: manifest.relations,
+        populations: manifest.populations,
+        axis_dispositions: manifest.axis_dispositions,
+        condition_rules: manifest.condition_rules,
+        conditions: manifest.conditions,
+        condition_exclusions: manifest.condition_exclusions,
+        property_dispositions: manifest.property_dispositions,
+        fact_cells: manifest.fact_cells,
+        facts: manifest.facts,
+        proof_obligations: manifest.proof_obligations,
+        oracles: manifest.oracles,
+        environments: manifest.environments,
+        blockers: manifest.blockers,
+    };
+}
+export function semanticFactCellIdentity(unitRef, conditionRef, propertyRef) {
+    return `${unitRef}\0${conditionRef}\0${propertyRef}`;
+}
+export function canonicalSemanticFactCondition(values) {
+    return values
+        .map((item) => `${item.axis_ref}=${item.value_ref}`)
+        .sort()
+        .join("|");
+}
+function semanticFactCartesian(values) {
+    return values.reduce((rows, current) => rows.flatMap((row) => current.map((value) => [...row, value])), [[]]);
+}
+export function assertNoSemanticFactParentCycle(key, subjects) {
+    const byKey = new Map(subjects.map((item) => [item.key, item]));
+    const seen = new Set();
+    let current = key;
+    while (current) {
+        if (seen.has(current))
+            semanticFactInvalid("subject_parent_cycle", key);
+        seen.add(current);
+        current = byKey.get(current)?.parent_ref ?? null;
+    }
+}
+export function requireSemanticFactBasis(value, label) {
+    uniqueNonemptySemanticFacts(value.basis_refs, `${label}:basis_refs`);
+}
+export function requireSemanticFactSubset(actual, allowed, code, label) {
+    const unknown = actual.filter((item) => !allowed.includes(item));
+    if (unknown.length)
+        semanticFactInvalid(code, `${label}:${unknown.join(",")}`);
+}
+export function uniqueNonemptySemanticFacts(values, label) {
+    if (!values.length)
+        semanticFactInvalid(`${label}_required`, "");
+    uniqueSemanticFacts(values, label);
+}
+export function uniqueSemanticFacts(values, label) {
+    if (new Set(values).size !== values.length)
+        semanticFactInvalid(`${label}_duplicate`, values.join(","));
+}
+export function assertSameSemanticFactSet(actual, expected, label) {
+    if (actual.length !== expected.length ||
+        new Set(actual).size !== actual.length ||
+        actual.some((item) => !expected.includes(item)))
+        semanticFactInvalid(`${label}_mismatch`, `expected=${[...expected].sort().join(",")};actual=${[...actual]
+            .sort()
+            .join(",")}`);
+}
+export function semanticFactInvalid(code, detail) {
+    throw new Error(`semantic_fact_manifest_invalid:${code}${detail ? `:${detail}` : ""}`);
+}

package/dist/lib/semantic-fact-policy-proofs.d.ts

@@ -0,0 +1,2 @@
+import type { SemanticFactManifestV1 } from "./semantic-fact-types.js";
+export declare function validateSemanticFactProofClosure(manifest: SemanticFactManifestV1): void;

package/dist/lib/semantic-fact-policy-proofs.js

@@ -0,0 +1,75 @@
+import { isCustomSemanticFactName, SEMANTIC_FACT_COMPARATORS, } from "./semantic-fact-catalog.js";
+import { assertSameSemanticFactSet, semanticFactInvalid, uniqueNonemptySemanticFacts, uniqueSemanticFacts, validateSemanticFactLocatedValue, } from "./semantic-fact-policy-primitives.js";
+export function validateSemanticFactProofClosure(manifest) {
+    const propertyByRef = new Map(manifest.property_dispositions.map((item) => [item.key, item]));
+    const factByRef = new Map(manifest.facts.map((item) => [item.key, item]));
+    const oracleByRef = new Map(manifest.oracles.map((item) => [item.key, item]));
+    const environmentByRef = new Map(manifest.environments.map((item) => [item.key, item]));
+    for (const fact of manifest.facts) {
+        const property = propertyByRef.get(fact.property_ref);
+        const proofs = manifest.proof_obligations.filter((item) => item.fact_ref === fact.key);
+        assertSameSemanticFactSet(proofs.map((item) => item.method), property.required_methods, `fact_proof_method_universe:${fact.key}`);
+        if (fact.quantifier.kind !== "one" &&
+            !proofs.some((proof) => proof.method === "population_set_equality"))
+            semanticFactInvalid("quantified_fact_population_proof_required", fact.key);
+    }
+    for (const proof of manifest.proof_obligations)
+        validateProof(manifest, proof, propertyByRef, factByRef, oracleByRef, environmentByRef);
+    for (const oracle of manifest.oracles) {
+        uniqueNonemptySemanticFacts(oracle.capabilities, `oracle_capabilities:${oracle.key}`);
+        if (oracle.trust === "frozen_executable" && !oracle.sha256)
+            semanticFactInvalid("frozen_oracle_sha256_required", oracle.key);
+        if (oracle.trust === "named_external_tcb" && oracle.sha256)
+            semanticFactInvalid("external_oracle_sha256_forbidden", oracle.key);
+    }
+    for (const environment of manifest.environments)
+        validateSemanticFactLocatedValue(manifest, environment.definition, `environment:${environment.key}`);
+}
+function validateProof(manifest, proof, propertyByRef, factByRef, oracleByRef, environmentByRef) {
+    const fact = factByRef.get(proof.fact_ref);
+    if (!fact)
+        semanticFactInvalid("proof_fact_unknown", `${proof.key}:${proof.fact_ref}`);
+    const property = propertyByRef.get(fact.property_ref);
+    assertSameSemanticFactSet(proof.evidence_capabilities, property.required_evidence_capabilities, `proof_capability_mismatch:${proof.key}`);
+    if (!proof.evidence_capabilities.includes("semantic_fact"))
+        semanticFactInvalid("proof_semantic_fact_capability_required", proof.key);
+    if (!SEMANTIC_FACT_COMPARATORS.includes(proof.comparison.comparator) &&
+        !isCustomSemanticFactName(proof.comparison.comparator))
+        semanticFactInvalid("proof_comparator_unknown", `${proof.key}:${proof.comparison.comparator}`);
+    if ((proof.comparison.mode === "exact" &&
+        proof.comparison.tolerance !== null) ||
+        (proof.comparison.mode === "tolerance" &&
+            proof.comparison.tolerance === null))
+        semanticFactInvalid("proof_tolerance_mode_mismatch", proof.key);
+    validateSemanticFactLocatedValue(manifest, proof.comparison.parameters, `proof:${proof.key}:parameters`);
+    if (proof.comparison.tolerance)
+        validateSemanticFactLocatedValue(manifest, proof.comparison.tolerance, `proof:${proof.key}:tolerance`);
+    if (proof.comparison.mask)
+        validateSemanticFactLocatedValue(manifest, proof.comparison.mask, `proof:${proof.key}:mask`);
+    const oracle = oracleByRef.get(proof.oracle_ref);
+    if (!oracle)
+        semanticFactInvalid("proof_oracle_unknown", `${proof.key}:${proof.oracle_ref}`);
+    for (const capability of [proof.method, proof.comparison.comparator])
+        if (!oracle.capabilities.includes(capability))
+            semanticFactInvalid("proof_oracle_capability_missing", `${proof.key}:${proof.oracle_ref}:${capability}`);
+    if (!environmentByRef.has(proof.environment_ref))
+        semanticFactInvalid("proof_environment_unknown", `${proof.key}:${proof.environment_ref}`);
+    uniqueSemanticFacts(proof.observer_refs, `proof_observer_refs:${proof.key}`);
+    uniqueSemanticFacts(proof.counterfactual.refs, `proof_counterfactual_refs:${proof.key}`);
+    validateProofCounterfactual(proof);
+}
+function validateProofCounterfactual(proof) {
+    if (proof.counterfactual.disposition === "required" &&
+        !proof.counterfactual.refs.length)
+        semanticFactInvalid("proof_counterfactual_required", proof.key);
+    if (proof.counterfactual.disposition === "not_applicable" &&
+        (!proof.counterfactual.basis_refs.length ||
+            proof.counterfactual.refs.length))
+        semanticFactInvalid("proof_counterfactual_na_basis_required", proof.key);
+    if (proof.counterfactual.disposition === "external" &&
+        proof.authority !== "external_confirmation")
+        semanticFactInvalid("proof_counterfactual_external_authority_required", proof.key);
+    if (proof.authority === "external_confirmation" &&
+        proof.counterfactual.disposition !== "external")
+        semanticFactInvalid("external_proof_counterfactual_external_required", proof.key);
+}

package/dist/lib/semantic-fact-policy-properties.d.ts

@@ -0,0 +1,3 @@
+import type { SemanticFactManifestIndexV1 } from "./semantic-fact-policy.js";
+import type { SemanticFactManifestV1 } from "./semantic-fact-types.js";
+export declare function validateSemanticFactPropertyClosure(manifest: SemanticFactManifestV1, units: SemanticFactManifestIndexV1["unit_by_ref"]): void;

package/dist/lib/semantic-fact-policy-properties.js

@@ -0,0 +1,84 @@
+import { isCustomSemanticFactName, SEMANTIC_FACT_PROOF_METHODS, SEMANTIC_FACT_STANDARD_PROPERTIES, } from "./semantic-fact-catalog.js";
+import { assertSameSemanticFactSet, requireSemanticFactBasis, semanticFactInvalid, uniqueNonemptySemanticFacts, uniqueSemanticFacts, } from "./semantic-fact-policy-primitives.js";
+export function validateSemanticFactPropertyClosure(manifest, units) {
+    const conditionByRef = new Map(manifest.conditions.map((item) => [item.key, item]));
+    for (const family of manifest.family_dispositions) {
+        const properties = manifest.property_dispositions.filter((item) => item.family_ref === family.key);
+        uniqueSemanticFacts(properties.map((item) => item.property), `family_property_identity:${family.key}`);
+        if (family.disposition !== "applicable") {
+            if (properties.length)
+                semanticFactInvalid("inapplicable_family_properties_forbidden", `${family.key}:${properties.map((item) => item.key).join(",")}`);
+            continue;
+        }
+        const familyUnits = [...units.values()].filter((item) => item.family_ref === family.key);
+        const standardProperties = family.standard
+            ? SEMANTIC_FACT_STANDARD_PROPERTIES[family.family]
+            : [];
+        if (!properties.length)
+            semanticFactInvalid("applicable_family_property_required", family.key);
+        assertSameSemanticFactSet(properties.filter((item) => item.standard).map((item) => item.property), [...standardProperties], `standard_property_universe:${family.key}`);
+        for (const property of properties)
+            validateProperty(manifest, property, family, familyUnits, standardProperties, units, conditionByRef);
+        for (const unit of familyUnits)
+            if (!properties.some((property) => property.applicable_unit_refs.includes(unit.key)))
+                semanticFactInvalid("applicable_unit_property_required", `${family.key}:${unit.key}`);
+    }
+}
+function validateProperty(manifest, property, family, familyUnits, standardProperties, units, conditionByRef) {
+    const knownStandard = standardProperties.includes(property.property);
+    if (property.standard !== knownStandard)
+        semanticFactInvalid("property_standard_flag_mismatch", `${family.key}:${property.property}`);
+    if (!property.standard && !isCustomSemanticFactName(property.property))
+        semanticFactInvalid("custom_property_name_required", property.property);
+    const partitions = [
+        property.applicable_unit_refs,
+        property.not_applicable_unit_refs,
+        property.decision_required_unit_refs,
+        property.unavailable_unit_refs,
+    ];
+    uniqueSemanticFacts(partitions.flat(), `property_unit_partition:${property.key}`);
+    assertSameSemanticFactSet(partitions.flat(), familyUnits.map((item) => item.key), `property_unit_universe:${property.key}`);
+    if (property.decision_required_unit_refs.length ||
+        property.unavailable_unit_refs.length)
+        semanticFactInvalid("property_unresolved", `${property.key}:${[
+            ...property.decision_required_unit_refs,
+            ...property.unavailable_unit_refs,
+        ].join(",")}`);
+    uniqueSemanticFacts(property.required_methods, `property_required_methods:${property.key}`);
+    uniqueSemanticFacts(property.required_evidence_capabilities, `property_required_capabilities:${property.key}`);
+    validatePropertyProof(property);
+    validatePropertyConditions(manifest, property, units, conditionByRef);
+    requireSemanticFactBasis(property, `property:${property.key}`);
+}
+function validatePropertyProof(property) {
+    if (property.applicable_unit_refs.length) {
+        uniqueNonemptySemanticFacts(property.required_methods, `property_required_methods:${property.key}`);
+        if (!property.required_evidence_capabilities.includes("semantic_fact"))
+            semanticFactInvalid("property_semantic_fact_capability_required", property.key);
+        for (const method of property.required_methods)
+            if (!SEMANTIC_FACT_PROOF_METHODS.includes(method) &&
+                !isCustomSemanticFactName(method))
+                semanticFactInvalid("property_proof_method_unknown", `${property.key}:${method}`);
+    }
+    else if (property.required_methods.length ||
+        property.required_evidence_capabilities.length ||
+        property.condition_refs.length)
+        semanticFactInvalid("inapplicable_property_proof_forbidden", property.key);
+}
+function validatePropertyConditions(manifest, property, units, conditionByRef) {
+    uniqueSemanticFacts(property.condition_refs, `property_condition_refs:${property.key}`);
+    for (const conditionRef of property.condition_refs) {
+        const condition = conditionByRef.get(conditionRef);
+        if (!condition)
+            semanticFactInvalid("property_condition_unknown", `${property.key}:${conditionRef}`);
+        if (!property.applicable_unit_refs.some((unitRef) => units.get(unitRef)?.outcome_ref === condition.outcome_ref))
+            semanticFactInvalid("property_condition_outcome_unused", `${property.key}:${conditionRef}`);
+    }
+    for (const unitRef of property.applicable_unit_refs) {
+        const unit = units.get(unitRef);
+        const expectedConditions = manifest.conditions
+            .filter((item) => item.outcome_ref === unit.outcome_ref)
+            .map((item) => item.key);
+        assertSameSemanticFactSet(property.condition_refs.filter((conditionRef) => conditionByRef.get(conditionRef)?.outcome_ref === unit.outcome_ref), expectedConditions, `property_condition_universe:${property.key}:${unitRef}`);
+    }
+}

package/dist/lib/semantic-fact-policy-units.d.ts

@@ -0,0 +1,4 @@
+import type { SemanticFactManifestIndexV1 } from "./semantic-fact-policy.js";
+import type { SemanticFactManifestV1 } from "./semantic-fact-types.js";
+export declare function validateSemanticFactFamilyClosure(manifest: SemanticFactManifestV1): void;
+export declare function validateSemanticFactUnits(manifest: SemanticFactManifestV1): SemanticFactManifestIndexV1["unit_by_ref"];

package/dist/lib/semantic-fact-policy-units.js

@@ -0,0 +1,103 @@
+import { isCustomSemanticFactName, SEMANTIC_FACT_STANDARD_FAMILIES, } from "./semantic-fact-catalog.js";
+import { assertNoSemanticFactParentCycle, assertSameSemanticFactSet, requireSemanticFactBasis, requireSemanticFactSubset, semanticFactInvalid, uniqueNonemptySemanticFacts, uniqueSemanticFacts, validateSemanticFactLocatedValue, } from "./semantic-fact-policy-primitives.js";
+export function validateSemanticFactFamilyClosure(manifest) {
+    const standardRows = manifest.family_dispositions.filter((item) => item.standard);
+    uniqueSemanticFacts(manifest.family_dispositions.flatMap((item) => item.outcome_refs.map((outcomeRef) => `${outcomeRef}\0${item.family}`)), "family_outcome_identity");
+    assertSameSemanticFactSet(standardRows.map((item) => item.family), [...SEMANTIC_FACT_STANDARD_FAMILIES], "standard_family_universe");
+    for (const family of manifest.family_dispositions) {
+        if (family.standard !==
+            SEMANTIC_FACT_STANDARD_FAMILIES.includes(family.family))
+            semanticFactInvalid("family_standard_flag_mismatch", family.family);
+        if (!family.standard && !isCustomSemanticFactName(family.family))
+            semanticFactInvalid("custom_family_name_required", family.family);
+        uniqueNonemptySemanticFacts(family.outcome_refs, `family_outcomes:${family.key}`);
+        requireSemanticFactSubset(family.outcome_refs, manifest.scope.outcome_refs, "family_outcome_unknown", family.key);
+        requireSemanticFactBasis(family, `family:${family.key}`);
+        if (family.disposition === "decision_required" ||
+            family.disposition === "unavailable")
+            semanticFactInvalid("family_unresolved", `${family.key}:${family.disposition}`);
+    }
+    for (const outcomeRef of manifest.scope.outcome_refs)
+        for (const family of SEMANTIC_FACT_STANDARD_FAMILIES) {
+            const rows = standardRows.filter((item) => item.family === family && item.outcome_refs.includes(outcomeRef));
+            if (rows.length !== 1)
+                semanticFactInvalid("standard_family_outcome_disposition_required", `${outcomeRef}:${family}:${rows.length}`);
+        }
+}
+export function validateSemanticFactUnits(manifest) {
+    const familyByRef = new Map(manifest.family_dispositions.map((item) => [item.key, item]));
+    const unitRows = [
+        ...manifest.subjects,
+        ...manifest.relations,
+        ...manifest.populations,
+    ];
+    uniqueSemanticFacts(unitRows.map((item) => item.key), "semantic_unit_key");
+    const units = new Map(unitRows.map((item) => [item.key, item]));
+    validateSemanticFactUnitFamilies(unitRows, familyByRef);
+    validateSemanticFactSubjectParents(manifest, units);
+    validateSemanticFactRelations(manifest, units);
+    validateSemanticFactPopulations(manifest, units);
+    validateSemanticFactApplicableFamilyMembers(manifest, unitRows);
+    return units;
+}
+function validateSemanticFactUnitFamilies(units, familyByRef) {
+    for (const unit of units) {
+        const family = familyByRef.get(unit.family_ref);
+        if (!family)
+            semanticFactInvalid("unit_family_unknown", `${unit.key}:${unit.family_ref}`);
+        if (family.disposition !== "applicable")
+            semanticFactInvalid("unit_family_not_applicable", `${unit.key}:${unit.family_ref}:${family.disposition}`);
+        if (unit.outcome_ref !== undefined &&
+            !family.outcome_refs.includes(unit.outcome_ref))
+            semanticFactInvalid("unit_outcome_family_mismatch", `${unit.key}:${unit.outcome_ref}:${unit.family_ref}`);
+        requireSemanticFactBasis(unit, `unit:${unit.key}`);
+    }
+}
+function validateSemanticFactSubjectParents(manifest, units) {
+    for (const subject of manifest.subjects) {
+        if (subject.parent_ref && !units.has(subject.parent_ref))
+            semanticFactInvalid("subject_parent_unknown", `${subject.key}:${subject.parent_ref}`);
+        assertNoSemanticFactParentCycle(subject.key, manifest.subjects);
+    }
+}
+function validateSemanticFactRelations(manifest, units) {
+    for (const relation of manifest.relations) {
+        if (relation.endpoints.length < 2)
+            semanticFactInvalid("relation_endpoints_required", relation.key);
+        uniqueSemanticFacts(relation.endpoints.map((item) => item.role), `relation_endpoint_role:${relation.key}`);
+        for (const endpoint of relation.endpoints)
+            if (!units.has(endpoint.unit_ref))
+                semanticFactInvalid("relation_endpoint_unknown", `${relation.key}:${endpoint.unit_ref}`);
+    }
+}
+function validateSemanticFactPopulations(manifest, units) {
+    for (const population of manifest.populations) {
+        uniqueSemanticFacts(population.member_unit_refs, `population_members:${population.key}`);
+        for (const unitRef of population.member_unit_refs)
+            if (!units.has(unitRef))
+                semanticFactInvalid("population_member_unknown", `${population.key}:${unitRef}`);
+        if (population.kind === "static" && !population.member_unit_refs.length)
+            semanticFactInvalid("static_population_members_required", population.key);
+        uniqueSemanticFacts(population.exclusion_refs, `population_exclusion_refs:${population.key}`);
+        if (population.kind === "static") {
+            if (population.universe.representation !== "inline" ||
+                !Array.isArray(population.universe.value) ||
+                population.universe.value.some((item) => typeof item !== "string"))
+                semanticFactInvalid("static_population_inline_universe_required", population.key);
+            assertSameSemanticFactSet(population.universe.value, population.member_unit_refs, `static_population_universe:${population.key}`);
+        }
+        validateSemanticFactLocatedValue(manifest, population.universe, `population:${population.key}:universe`);
+    }
+}
+function validateSemanticFactApplicableFamilyMembers(manifest, units) {
+    for (const family of manifest.family_dispositions) {
+        const members = units.filter((item) => item.family_ref === family.key);
+        if (family.disposition === "applicable") {
+            for (const outcomeRef of family.outcome_refs)
+                if (!members.some((item) => item.outcome_ref === outcomeRef))
+                    semanticFactInvalid("applicable_family_unit_required", `${family.key}:${outcomeRef}`);
+        }
+        else if (members.length)
+            semanticFactInvalid("inapplicable_family_units_forbidden", `${family.key}:${members.map((item) => item.key).join(",")}`);
+    }
+}

package/dist/lib/semantic-fact-policy.d.ts

@@ -0,0 +1,17 @@
+import type { SemanticFactManifestV1 } from "./semantic-fact-types.js";
+export { semanticFactCollectionIdentity } from "./semantic-fact-policy-authority.js";
+export interface SemanticFactManifestIndexV1 {
+    family_by_ref: Map<string, SemanticFactManifestV1["family_dispositions"][number]>;
+    unit_by_ref: Map<string, SemanticFactManifestV1["subjects"][number] | SemanticFactManifestV1["relations"][number] | SemanticFactManifestV1["populations"][number]>;
+    condition_by_ref: Map<string, SemanticFactManifestV1["conditions"][number]>;
+    property_by_ref: Map<string, SemanticFactManifestV1["property_dispositions"][number]>;
+    fact_by_ref: Map<string, SemanticFactManifestV1["facts"][number]>;
+    proof_by_ref: Map<string, SemanticFactManifestV1["proof_obligations"][number]>;
+    oracle_by_ref: Map<string, SemanticFactManifestV1["oracles"][number]>;
+    environment_by_ref: Map<string, SemanticFactManifestV1["environments"][number]>;
+}
+export declare function validateSemanticFactManifestPolicy(manifest: SemanticFactManifestV1): SemanticFactManifestIndexV1;
+export declare const complete_non_ui_semantic_fact_delivery = "expected=source=contract;proofs=current";
+export declare const NO_UI_CONTROL_RELATIONS = true;
+export declare const NO_SEMANTIC_FACT_SHORTCUTS = true;
+export declare const SEMANTIC_INVENTORY_IS_NOT_COMPLETION = true;

package/dist/lib/semantic-fact-policy.js

@@ -0,0 +1,41 @@
+import { validateSemanticFactGeneration, validateSemanticFactInspector, validateSemanticFactSourceLineage, validateSemanticFactUniqueIdentities, } from "./semantic-fact-policy-authority.js";
+import { validateSemanticFactInspectorCensus } from "./semantic-fact-policy-census.js";
+import { validateSemanticFactAxisAndConditionClosure } from "./semantic-fact-policy-conditions.js";
+import { validateSemanticFactClosure } from "./semantic-fact-policy-facts.js";
+import { semanticFactInvalid } from "./semantic-fact-policy-primitives.js";
+import { validateSemanticFactProofClosure } from "./semantic-fact-policy-proofs.js";
+import { validateSemanticFactPropertyClosure } from "./semantic-fact-policy-properties.js";
+import { validateSemanticFactFamilyClosure, validateSemanticFactUnits, } from "./semantic-fact-policy-units.js";
+export { semanticFactCollectionIdentity } from "./semantic-fact-policy-authority.js";
+export function validateSemanticFactManifestPolicy(manifest) {
+    validateSemanticFactUniqueIdentities(manifest);
+    validateSemanticFactGeneration(manifest);
+    validateSemanticFactInspector(manifest);
+    validateSemanticFactSourceLineage(manifest);
+    validateSemanticFactFamilyClosure(manifest);
+    const units = validateSemanticFactUnits(manifest);
+    validateSemanticFactAxisAndConditionClosure(manifest);
+    validateSemanticFactPropertyClosure(manifest, units);
+    validateSemanticFactClosure(manifest, units);
+    validateSemanticFactProofClosure(manifest);
+    validateSemanticFactInspectorCensus(manifest);
+    if (manifest.blockers.length)
+        semanticFactInvalid("blockers_present", manifest.blockers
+            .map((item) => item.key)
+            .sort()
+            .join(","));
+    return {
+        family_by_ref: new Map(manifest.family_dispositions.map((item) => [item.key, item])),
+        unit_by_ref: units,
+        condition_by_ref: new Map(manifest.conditions.map((item) => [item.key, item])),
+        property_by_ref: new Map(manifest.property_dispositions.map((item) => [item.key, item])),
+        fact_by_ref: new Map(manifest.facts.map((item) => [item.key, item])),
+        proof_by_ref: new Map(manifest.proof_obligations.map((item) => [item.key, item])),
+        oracle_by_ref: new Map(manifest.oracles.map((item) => [item.key, item])),
+        environment_by_ref: new Map(manifest.environments.map((item) => [item.key, item])),
+    };
+}
+export const complete_non_ui_semantic_fact_delivery = "expected=source=contract;proofs=current";
+export const NO_UI_CONTROL_RELATIONS = true;
+export const NO_SEMANTIC_FACT_SHORTCUTS = true;
+export const SEMANTIC_INVENTORY_IS_NOT_COMPLETION = true;

package/dist/lib/semantic-fact-proof-shape.d.ts

@@ -0,0 +1,51 @@
+export declare function parseSemanticFacts(value: unknown, label: string): {
+    key: string;
+    cell_ref: string;
+    outcome_ref: string;
+    unit_ref: string;
+    family_ref: string;
+    condition_ref: string;
+    property_ref: string;
+    owner_ref: string;
+    value_kind: "boolean" | "custom" | "decision_table" | "digest" | "duration" | "enum" | "formula" | "number" | "object" | "ordered_list" | "range" | "rate" | "ratio" | "relation" | "schema" | "set" | "string" | "timestamp" | "trace";
+    observation_scope: "data_boundary" | "external_boundary" | "implementation_structure" | "operational_boundary" | "product_boundary" | "security_boundary" | "service_boundary";
+    observation_sensitivity: "plain" | "protected";
+    quantifier: {
+        kind: "all" | "any" | "at_least" | "at_most" | "exactly" | "none" | "one" | "range";
+        minimum: number | null;
+        maximum: number | null;
+        population_ref: string | null;
+    };
+    expected: import("./semantic-fact-base-types.js").SemanticFactLocatedValueV1;
+    provenance: {
+        kind: "direct" | "evidence_backed_preservation" | "explicitly_delegated" | "logically_derived";
+        authority_ref: string;
+        basis_refs: string[];
+        derivation: string | null;
+    };
+    source_item_refs: string[];
+}[];
+export declare function parseSemanticFactProofObligations(value: unknown, label: string): {
+    key: string;
+    fact_ref: string;
+    method: string;
+    authority: "external_confirmation" | "machine";
+    proof_surface: "api_contract" | "data_state" | "implementation_structure" | "population_coverage" | "runtime_behavior" | "security_boundary" | "ui_browser";
+    evidence_capabilities: ("boundary_invocation" | "cross_surface_consistency" | "design_conformance" | "design_method" | "durable_readback" | "external_side_effect" | "failure_injection" | "input_variation" | "interaction_trace" | "presence" | "semantic_fact" | "state_delta" | "target_runtime" | "visual_render")[];
+    comparison: {
+        comparator: string;
+        mode: "exact" | "tolerance";
+        parameters: import("./semantic-fact-base-types.js").SemanticFactLocatedValueV1;
+        tolerance: import("./semantic-fact-base-types.js").SemanticFactLocatedValueV1 | null;
+        mask: import("./semantic-fact-base-types.js").SemanticFactLocatedValueV1 | null;
+    };
+    oracle_ref: string;
+    environment_ref: string;
+    observer_refs: string[];
+    counterfactual: {
+        disposition: "external" | "not_applicable" | "required";
+        refs: string[];
+        basis_refs: string[];
+        rationale: string;
+    };
+}[];