project-tiny-context-harness 0.8.4 → 0.8.5

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

@@ -0,0 +1,79 @@
+import { SEMANTIC_FACT_REQUIRED_INSPECTOR_CAPABILITIES } from "./semantic-fact-catalog.js";
+import { assertSameSemanticFactSet, requireSemanticFactBasis, requireSemanticFactSubset, semanticFactCollections, semanticFactInvalid, uniqueNonemptySemanticFacts, uniqueSemanticFacts, } from "./semantic-fact-policy-primitives.js";
+import { SEMANTIC_FACT_MANIFEST_COLLECTIONS, } from "./semantic-fact-types.js";
+import { canonicalValueJson, sha256Hex } from "./strict-codec.js";
+export function validateSemanticFactInspector(manifest) {
+    uniqueNonemptySemanticFacts(manifest.inspector.capabilities, "inspector_capabilities");
+    requireSemanticFactSubset([...SEMANTIC_FACT_REQUIRED_INSPECTOR_CAPABILITIES], manifest.inspector.capabilities, "inspector_capability_missing", manifest.key);
+    if (manifest.inspector.trust === "frozen_executable"
+        ? !manifest.inspector.implementation_sha256
+        : manifest.inspector.implementation_sha256 !== null)
+        semanticFactInvalid("inspector_identity_digest_mismatch", `${manifest.inspector.trust}:${manifest.inspector.implementation_sha256 ?? "missing"}`);
+}
+export function validateSemanticFactSourceLineage(manifest) {
+    const validate = (label, row) => {
+        uniqueNonemptySemanticFacts(row.source_item_refs, `${label}_source_items:${row.key}`);
+        requireSemanticFactSubset(row.source_item_refs, manifest.scope.source_item_refs, `${label}_source_item_unknown`, row.key);
+    };
+    for (const row of manifest.scope.exclusions) {
+        validate("scope_exclusion", row);
+        uniqueNonemptySemanticFacts(row.affected_refs, `scope_exclusion_affected_refs:${row.key}`);
+        requireSemanticFactBasis(row, `scope_exclusion:${row.key}`);
+    }
+    for (const row of manifest.family_dispositions)
+        validate("family", row);
+    for (const row of manifest.subjects)
+        validate("subject", row);
+    for (const row of manifest.relations)
+        validate("relation", row);
+    for (const row of manifest.populations)
+        validate("population", row);
+    for (const row of manifest.axis_dispositions) {
+        validate("axis", row);
+        for (const value of row.values)
+            validate(`axis_value:${row.key}`, value);
+    }
+    for (const row of manifest.condition_rules)
+        validate("condition_rule", row);
+    for (const row of manifest.conditions)
+        validate("condition", row);
+    for (const row of manifest.condition_exclusions)
+        validate("condition_exclusion", row);
+    for (const row of manifest.property_dispositions)
+        validate("property", row);
+    for (const row of manifest.fact_cells)
+        validate("fact_cell", row);
+    for (const row of manifest.facts)
+        validate("fact", row);
+    for (const row of manifest.blockers) {
+        validate("blocker", row);
+        uniqueNonemptySemanticFacts(row.affected_refs, `blocker_affected_refs:${row.key}`);
+    }
+}
+export function semanticFactCollectionIdentity(rows) {
+    return sha256Hex(canonicalValueJson(rows.map((item) => item.key).sort()));
+}
+export function validateSemanticFactUniqueIdentities(manifest) {
+    uniqueNonemptySemanticFacts(manifest.scope.outcome_refs, "scope_outcome_refs");
+    uniqueNonemptySemanticFacts(manifest.scope.source_item_refs, "scope_source_item_refs");
+    uniqueSemanticFacts(manifest.inputs.map((item) => `${item.kind}\0${item.source_ref}`), "input_resource");
+    for (const [name, rows] of Object.entries(semanticFactCollections(manifest)))
+        uniqueSemanticFacts(rows.map((item) => item.key), `${name}_key`);
+    uniqueSemanticFacts(manifest.inspector.census.map((item) => item.key), "inspector_census_key");
+    uniqueSemanticFacts(manifest.generation.collections.map((item) => item.name), "generation_collection_name");
+    uniqueSemanticFacts(manifest.generation.chunk_indexes, "generation_chunk_index");
+    const expectedChunks = Array.from({ length: manifest.generation.chunk_count }, (_unused, index) => index);
+    assertSameSemanticFactSet(manifest.generation.chunk_indexes, expectedChunks, "generation_chunk_indexes");
+}
+export function validateSemanticFactGeneration(manifest) {
+    assertSameSemanticFactSet(manifest.generation.collections.map((item) => item.name), [...SEMANTIC_FACT_MANIFEST_COLLECTIONS], "generation_collection_set");
+    const actual = semanticFactCollections(manifest);
+    for (const declaration of manifest.generation.collections) {
+        const rows = actual[declaration.name];
+        if (declaration.expected_count !== rows.length)
+            semanticFactInvalid("generation_collection_count_mismatch", `${declaration.name}:${declaration.expected_count}:${rows.length}`);
+        const digest = semanticFactCollectionIdentity(rows);
+        if (declaration.identity_sha256 !== digest)
+            semanticFactInvalid("generation_collection_identity_mismatch", `${declaration.name}:${declaration.identity_sha256}:${digest}`);
+    }
+}

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

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

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

@@ -0,0 +1,80 @@
+import { assertSameSemanticFactSet, requireSemanticFactBasis, semanticFactInvalid, validateSemanticFactLocator, } from "./semantic-fact-policy-primitives.js";
+import { canonicalValueJson, sha256Hex } from "./strict-codec.js";
+export function validateSemanticFactInspectorCensus(manifest) {
+    const factRefs = new Set(manifest.facts.map((item) => item.key));
+    const factsFor = (predicate) => manifest.facts.filter(predicate).map((item) => item.key);
+    const expected = expectedCensusRows(manifest, factsFor);
+    const actual = new Set();
+    for (const entry of manifest.inspector.census) {
+        const identity = `${entry.kind}:${entry.key}`;
+        actual.add(identity);
+        const expectedEntry = expected.get(identity);
+        if (!expectedEntry)
+            semanticFactInvalid("census_identity_unknown", identity);
+        if (entry.locator.material_ref !== manifest.key ||
+            entry.locator.kind !== "manifest_pointer" ||
+            entry.locator.value !== expectedEntry.pointer)
+            semanticFactInvalid("census_locator_mismatch", identity);
+        const identityDigest = sha256Hex(canonicalValueJson(expectedEntry.row));
+        if (entry.identity_sha256 !== identityDigest)
+            semanticFactInvalid("census_identity_digest_mismatch", `${identity}:${entry.identity_sha256}:${identityDigest}`);
+        for (const factRef of entry.fact_refs)
+            if (!factRefs.has(factRef))
+                semanticFactInvalid("census_fact_unknown", `${entry.key}:${factRef}`);
+        assertSameSemanticFactSet(entry.fact_refs, expectedEntry.fact_refs, `census_fact_set:${identity}`);
+        const expectedDisposition = expectedEntry.fact_refs.length
+            ? "material_with_facts"
+            : "supporting_only";
+        if (entry.disposition !== expectedDisposition)
+            semanticFactInvalid("census_disposition_mismatch", `${identity}:${entry.disposition}:${expectedDisposition}`);
+        validateSemanticFactLocator(manifest, entry.locator, `census:${entry.key}`);
+        requireSemanticFactBasis(entry, `census:${entry.key}`);
+    }
+    assertSameSemanticFactSet([...actual], [...expected.keys()], "inspector_census_universe");
+}
+function expectedCensusRows(manifest, factsFor) {
+    const result = new Map();
+    const add = (kind, key, pointer, row, factRefs) => result.set(`${kind}:${key}`, {
+        pointer,
+        row,
+        fact_refs: [...new Set(factRefs)].sort(),
+    });
+    manifest.inputs.forEach((row, index) => add("input", row.key, `/inputs/${index}`, row, row.fact_refs));
+    manifest.scope.exclusions.forEach((row, index) => add("scope_exclusion", row.key, `/scope/exclusions/${index}`, row, row.affected_refs.filter((ref) => manifest.facts.some((fact) => fact.key === ref))));
+    manifest.family_dispositions.forEach((row, index) => add("family", row.key, `/family_dispositions/${index}`, row, factsFor((fact) => fact.family_ref === row.key)));
+    manifest.subjects.forEach((row, index) => add("subject", row.key, `/subjects/${index}`, row, factsFor((fact) => fact.unit_ref === row.key)));
+    manifest.relations.forEach((row, index) => add("relation", row.key, `/relations/${index}`, row, factsFor((fact) => fact.unit_ref === row.key)));
+    manifest.populations.forEach((row, index) => add("population", row.key, `/populations/${index}`, row, factsFor((fact) => fact.unit_ref === row.key ||
+        fact.quantifier.population_ref === row.key)));
+    addAxisCensusRows(manifest, factsFor, add);
+    manifest.condition_rules.forEach((row, index) => add("condition_rule", row.key, `/condition_rules/${index}`, row, factsFor((fact) => row.condition_refs.includes(fact.condition_ref))));
+    manifest.conditions.forEach((row, index) => add("condition", row.key, `/conditions/${index}`, row, factsFor((fact) => fact.condition_ref === row.key)));
+    manifest.condition_exclusions.forEach((row, index) => add("condition", row.key, `/condition_exclusions/${index}`, row, []));
+    manifest.property_dispositions.forEach((row, index) => add("property", row.key, `/property_dispositions/${index}`, row, factsFor((fact) => fact.property_ref === row.key)));
+    manifest.fact_cells.forEach((row, index) => add("fact_cell", row.key, `/fact_cells/${index}`, row, row.fact_ref ? [row.fact_ref] : []));
+    manifest.facts.forEach((row, index) => add("fact", row.key, `/facts/${index}`, row, [row.key]));
+    manifest.proof_obligations.forEach((row, index) => add("proof_obligation", row.key, `/proof_obligations/${index}`, row, [
+        row.fact_ref,
+    ]));
+    addProofSupportCensusRows(manifest, add);
+    return result;
+}
+function addAxisCensusRows(manifest, factsFor, add) {
+    manifest.axis_dispositions.forEach((row, axisIndex) => {
+        add("axis", row.key, `/axis_dispositions/${axisIndex}`, row, factsFor((fact) => manifest.conditions
+            .find((condition) => condition.key === fact.condition_ref)
+            ?.axis_values.some((value) => value.axis_ref === row.key) ?? false));
+        row.values.forEach((value, valueIndex) => add("axis_value", `${row.key}:${value.key}`, `/axis_dispositions/${axisIndex}/values/${valueIndex}`, value, factsFor((fact) => manifest.conditions
+            .find((condition) => condition.key === fact.condition_ref)
+            ?.axis_values.some((entry) => entry.axis_ref === row.key && entry.value_ref === value.key) ?? false)));
+    });
+}
+function addProofSupportCensusRows(manifest, add) {
+    manifest.oracles.forEach((row, index) => add("oracle", row.key, `/oracles/${index}`, row, manifest.proof_obligations
+        .filter((proof) => proof.oracle_ref === row.key)
+        .map((proof) => proof.fact_ref)));
+    manifest.environments.forEach((row, index) => add("environment", row.key, `/environments/${index}`, row, manifest.proof_obligations
+        .filter((proof) => proof.environment_ref === row.key)
+        .map((proof) => proof.fact_ref)));
+    manifest.blockers.forEach((row, index) => add("blocker", row.key, `/blockers/${index}`, row, row.affected_refs.filter((ref) => manifest.facts.some((fact) => fact.key === ref))));
+}

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

@@ -0,0 +1,7 @@
+import type { SemanticFactManifestV1 } from "./semantic-fact-types.js";
+type Axis = SemanticFactManifestV1["axis_dispositions"][number];
+type Condition = SemanticFactManifestV1["conditions"][number];
+type Exclusion = SemanticFactManifestV1["condition_exclusions"][number];
+export declare function validateSemanticFactConditionRuleReferences(rule: SemanticFactManifestV1["condition_rules"][number], outcomeRef: string, conditionByRef: Map<string, Condition>, exclusionByRef: Map<string, Exclusion>): void;
+export declare function validateSemanticFactAxisValueCoverage(outcomeRef: string, axes: Map<string, Axis>, rows: Array<Condition | Exclusion>): void;
+export {};

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

@@ -0,0 +1,19 @@
+import { semanticFactInvalid } from "./semantic-fact-policy-primitives.js";
+export function validateSemanticFactConditionRuleReferences(rule, outcomeRef, conditionByRef, exclusionByRef) {
+    for (const ref of rule.condition_refs) {
+        const row = conditionByRef.get(ref);
+        if (!row || row.outcome_ref !== outcomeRef)
+            semanticFactInvalid("condition_rule_condition_unknown", `${rule.key}:${ref}`);
+    }
+    for (const ref of rule.exclusion_refs) {
+        const row = exclusionByRef.get(ref);
+        if (!row || row.outcome_ref !== outcomeRef)
+            semanticFactInvalid("condition_rule_exclusion_unknown", `${rule.key}:${ref}`);
+    }
+}
+export function validateSemanticFactAxisValueCoverage(outcomeRef, axes, rows) {
+    for (const axis of axes.values())
+        for (const value of axis.values)
+            if (!rows.some((item) => item.axis_values.some((entry) => entry.axis_ref === axis.key && entry.value_ref === value.key)))
+                semanticFactInvalid("axis_value_uncovered", `${outcomeRef}:${axis.key}:${value.key}`);
+}

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

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

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

@@ -0,0 +1,105 @@
+import { isAtomicSemanticFactAtom, isCustomSemanticFactName, SEMANTIC_FACT_STANDARD_CONDITION_AXES, } from "./semantic-fact-catalog.js";
+import { validateSemanticFactAxisValueCoverage, validateSemanticFactConditionRuleReferences, } from "./semantic-fact-policy-condition-references.js";
+import { assertSameSemanticFactSet, canonicalSemanticFactCondition, requireSemanticFactBasis, requireSemanticFactSubset, semanticFactInvalid, uniqueNonemptySemanticFacts, uniqueSemanticFacts, validateSemanticFactCrossProduct, } from "./semantic-fact-policy-primitives.js";
+export function validateSemanticFactAxisAndConditionClosure(manifest) {
+    validateAxisCatalog(manifest);
+    const conditionByRef = new Map(manifest.conditions.map((item) => [item.key, item]));
+    const exclusionByRef = new Map(manifest.condition_exclusions.map((item) => [item.key, item]));
+    for (const exclusion of manifest.condition_exclusions)
+        if (exclusion.disposition === "decision_required" ||
+            exclusion.disposition === "unavailable")
+            semanticFactInvalid("condition_exclusion_unresolved", `${exclusion.key}:${exclusion.disposition}`);
+    for (const outcomeRef of manifest.scope.outcome_refs)
+        validateOutcomeConditions(manifest, outcomeRef, conditionByRef, exclusionByRef);
+}
+function validateAxisCatalog(manifest) {
+    const standardRows = manifest.axis_dispositions.filter((item) => item.standard);
+    uniqueSemanticFacts(manifest.axis_dispositions.flatMap((item) => item.outcome_refs.map((outcomeRef) => `${outcomeRef}\0${item.axis}`)), "axis_outcome_identity");
+    for (const axis of manifest.axis_dispositions)
+        validateAxis(manifest, axis);
+    for (const outcomeRef of manifest.scope.outcome_refs)
+        for (const axis of SEMANTIC_FACT_STANDARD_CONDITION_AXES) {
+            const rows = standardRows.filter((item) => item.axis === axis && item.outcome_refs.includes(outcomeRef));
+            if (rows.length !== 1)
+                semanticFactInvalid("standard_axis_outcome_disposition_required", `${outcomeRef}:${axis}:${rows.length}`);
+        }
+}
+function validateAxis(manifest, axis) {
+    const isStandard = SEMANTIC_FACT_STANDARD_CONDITION_AXES.includes(axis.axis);
+    if (axis.standard !== isStandard)
+        semanticFactInvalid("axis_standard_flag_mismatch", axis.axis);
+    if (!axis.standard && !isCustomSemanticFactName(axis.axis))
+        semanticFactInvalid("custom_axis_name_required", axis.axis);
+    uniqueNonemptySemanticFacts(axis.outcome_refs, `axis_outcomes:${axis.key}`);
+    requireSemanticFactSubset(axis.outcome_refs, manifest.scope.outcome_refs, "axis_outcome_unknown", axis.key);
+    uniqueSemanticFacts(axis.values.map((item) => item.key), `axis_values:${axis.key}`);
+    for (const value of axis.values) {
+        if (!isAtomicSemanticFactAtom(value.key))
+            semanticFactInvalid("axis_value_not_atomic", `${axis.key}:${value.key}`);
+        requireSemanticFactBasis(value, `axis_value:${axis.key}:${value.key}`);
+    }
+    if (axis.disposition === "applicable" && !axis.values.length)
+        semanticFactInvalid("applicable_axis_values_required", axis.key);
+    if (axis.disposition !== "applicable" && axis.values.length)
+        semanticFactInvalid("inapplicable_axis_values_forbidden", `${axis.key}:${axis.disposition}`);
+    if (axis.disposition === "decision_required" ||
+        axis.disposition === "unavailable")
+        semanticFactInvalid("axis_unresolved", `${axis.key}:${axis.disposition}`);
+    requireSemanticFactBasis(axis, `axis:${axis.key}`);
+}
+function validateOutcomeConditions(manifest, outcomeRef, conditionByRef, exclusionByRef) {
+    const applicableAxes = manifest.axis_dispositions.filter((item) => item.disposition === "applicable" &&
+        item.outcome_refs.includes(outcomeRef));
+    const axisByRef = new Map(applicableAxes.map((item) => [item.key, item]));
+    const expectedAxes = [...axisByRef.keys()].sort();
+    const conditions = manifest.conditions.filter((item) => item.outcome_ref === outcomeRef);
+    const exclusions = manifest.condition_exclusions.filter((item) => item.outcome_ref === outcomeRef);
+    if (!conditions.length)
+        semanticFactInvalid("condition_required", outcomeRef);
+    validateConditionRows([...conditions, ...exclusions], axisByRef, expectedAxes);
+    uniqueSemanticFacts([...conditions, ...exclusions].map((item) => canonicalSemanticFactCondition(item.axis_values)), `condition_combination:${outcomeRef}`);
+    const rules = manifest.condition_rules.filter((item) => item.outcome_ref === outcomeRef);
+    if (!applicableAxes.length) {
+        if (rules.length)
+            semanticFactInvalid("condition_rules_without_axes", outcomeRef);
+        if (conditions.length !== 1 ||
+            conditions[0].axis_values.length ||
+            exclusions.length)
+            semanticFactInvalid("baseline_condition_required", outcomeRef);
+        return;
+    }
+    if (rules.length !== 1)
+        semanticFactInvalid("condition_rule_complete_expansion_required", `${outcomeRef}:${rules.length}`);
+    validateOutcomeConditionRule(rules[0], outcomeRef, axisByRef, expectedAxes, conditions, exclusions, conditionByRef, exclusionByRef);
+}
+function validateConditionRows(rows, axisByRef, expectedAxes) {
+    for (const row of rows) {
+        uniqueSemanticFacts(row.axis_values.map((item) => item.axis_ref), `condition_axis:${row.key}`);
+        assertSameSemanticFactSet(row.axis_values.map((item) => item.axis_ref), expectedAxes, `condition_axis_set:${row.key}`);
+        for (const axisValue of row.axis_values) {
+            const axis = axisByRef.get(axisValue.axis_ref);
+            if (!axis)
+                semanticFactInvalid("condition_axis_unknown", `${row.key}:${axisValue.axis_ref}`);
+            if (!axis.values.some((item) => item.key === axisValue.value_ref))
+                semanticFactInvalid("condition_axis_value_unknown", `${row.key}:${axisValue.axis_ref}:${axisValue.value_ref}`);
+        }
+        requireSemanticFactBasis(row, `condition:${row.key}`);
+    }
+}
+function validateOutcomeConditionRule(rule, outcomeRef, axisByRef, expectedAxes, conditions, exclusions, conditionByRef, exclusionByRef) {
+    assertSameSemanticFactSet(rule.axis_refs, expectedAxes, `condition_rule_axis_universe:${outcomeRef}`);
+    uniqueNonemptySemanticFacts(rule.axis_refs, `condition_rule_axes:${rule.key}`);
+    uniqueSemanticFacts(rule.condition_refs, `condition_rule_conditions:${rule.key}`);
+    uniqueSemanticFacts(rule.exclusion_refs, `condition_rule_exclusions:${rule.key}`);
+    requireSemanticFactBasis(rule, `condition_rule:${rule.key}`);
+    validateSemanticFactConditionRuleReferences(rule, outcomeRef, conditionByRef, exclusionByRef);
+    if (!rule.condition_refs.length && !rule.exclusion_refs.length)
+        semanticFactInvalid("condition_rule_cells_required", rule.key);
+    validateSemanticFactCrossProduct(rule, axisByRef, conditionByRef, exclusionByRef);
+    assertSameSemanticFactSet(rule.condition_refs, conditions.map((item) => item.key), `condition_rule_condition_closure:${outcomeRef}`);
+    assertSameSemanticFactSet(rule.exclusion_refs, exclusions.map((item) => item.key), `condition_rule_exclusion_closure:${outcomeRef}`);
+    validateSemanticFactAxisValueCoverage(outcomeRef, axisByRef, [
+        ...conditions,
+        ...exclusions,
+    ]);
+}

package/dist/lib/semantic-fact-policy-facts.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 validateSemanticFactClosure(manifest: SemanticFactManifestV1, units: SemanticFactManifestIndexV1["unit_by_ref"]): void;

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

@@ -0,0 +1,73 @@
+import { assertSameSemanticFactSet, requireSemanticFactBasis, requireSemanticFactSubset, semanticFactCellIdentity, semanticFactInvalid, uniqueNonemptySemanticFacts, validateSemanticFactLocatedValue, validateSemanticFactQuantifier, } from "./semantic-fact-policy-primitives.js";
+export function validateSemanticFactClosure(manifest, units) {
+    const propertyByRef = new Map(manifest.property_dispositions.map((item) => [item.key, item]));
+    const conditionByRef = new Map(manifest.conditions.map((item) => [item.key, item]));
+    const expectedCells = [];
+    for (const property of manifest.property_dispositions)
+        for (const unitRef of property.applicable_unit_refs) {
+            const unit = units.get(unitRef);
+            for (const conditionRef of property.condition_refs)
+                if (conditionByRef.get(conditionRef)?.outcome_ref === unit.outcome_ref)
+                    expectedCells.push(semanticFactCellIdentity(unitRef, conditionRef, property.key));
+        }
+    assertSameSemanticFactSet(manifest.fact_cells.map((item) => semanticFactCellIdentity(item.unit_ref, item.condition_ref, item.property_ref)), expectedCells, "fact_cell_universe");
+    const factByRef = new Map(manifest.facts.map((item) => [item.key, item]));
+    const specifiedRefs = [];
+    for (const cell of manifest.fact_cells)
+        validateFactCell(cell, units, propertyByRef, conditionByRef, factByRef, specifiedRefs);
+    assertSameSemanticFactSet(specifiedRefs, manifest.facts.map((item) => item.key), "specified_fact_set");
+    for (const fact of manifest.facts)
+        validateFact(manifest, fact);
+}
+function validateFactCell(cell, units, propertyByRef, conditionByRef, factByRef, specifiedRefs) {
+    const unit = units.get(cell.unit_ref);
+    const property = propertyByRef.get(cell.property_ref);
+    const condition = conditionByRef.get(cell.condition_ref);
+    if (!unit || !property || !condition)
+        semanticFactInvalid("fact_cell_reference_unknown", `${cell.key}:${cell.unit_ref}:${cell.condition_ref}:${cell.property_ref}`);
+    if (cell.outcome_ref !== unit.outcome_ref ||
+        condition.outcome_ref !== unit.outcome_ref)
+        semanticFactInvalid("fact_cell_outcome_mismatch", cell.key);
+    if (cell.disposition === "decision_required" ||
+        cell.disposition === "unavailable")
+        semanticFactInvalid("fact_cell_unresolved", `${cell.key}:${cell.disposition}`);
+    if (cell.disposition === "specified") {
+        if (!cell.fact_ref)
+            semanticFactInvalid("specified_fact_cell_ref_required", cell.key);
+        specifiedRefs.push(cell.fact_ref);
+        const fact = factByRef.get(cell.fact_ref);
+        if (!fact)
+            semanticFactInvalid("fact_cell_fact_unknown", `${cell.key}:${cell.fact_ref}`);
+        if (fact.cell_ref !== cell.key ||
+            fact.outcome_ref !== cell.outcome_ref ||
+            fact.unit_ref !== cell.unit_ref ||
+            fact.condition_ref !== cell.condition_ref ||
+            fact.property_ref !== cell.property_ref ||
+            fact.family_ref !== unit.family_ref ||
+            fact.value_kind !== property.value_kind)
+            semanticFactInvalid("fact_cell_fact_identity_mismatch", cell.key);
+    }
+    else if (cell.fact_ref)
+        semanticFactInvalid("non_specified_fact_cell_ref_forbidden", cell.key);
+    requireSemanticFactBasis(cell, `fact_cell:${cell.key}`);
+}
+function validateFact(manifest, fact) {
+    uniqueNonemptySemanticFacts(fact.source_item_refs, `fact_source_items:${fact.key}`);
+    requireSemanticFactSubset(fact.source_item_refs, manifest.scope.source_item_refs, "fact_source_item_unknown", fact.key);
+    if (!fact.provenance.basis_refs.length)
+        semanticFactInvalid("fact_provenance_basis_required", fact.key);
+    if (fact.provenance.kind === "logically_derived" &&
+        !fact.provenance.derivation)
+        semanticFactInvalid("fact_derivation_required", fact.key);
+    if (fact.provenance.kind !== "logically_derived" &&
+        fact.provenance.derivation)
+        semanticFactInvalid("fact_derivation_forbidden", fact.key);
+    if (fact.observation_sensitivity === "protected" &&
+        fact.expected.representation !== "digest_only")
+        semanticFactInvalid("protected_fact_digest_only_required", fact.key);
+    if (fact.observation_sensitivity === "plain" &&
+        fact.expected.representation === "digest_only")
+        semanticFactInvalid("plain_fact_digest_only_forbidden", fact.key);
+    validateSemanticFactLocatedValue(manifest, fact.expected, `fact:${fact.key}:expected`);
+    validateSemanticFactQuantifier(manifest, fact);
+}

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

@@ -0,0 +1,26 @@
+import type { SemanticFactManifestCollectionName, SemanticFactManifestV1 } from "./semantic-fact-types.js";
+export declare function validateSemanticFactLocatedValue(manifest: SemanticFactManifestV1, located: SemanticFactManifestV1["facts"][number]["expected"], label: string): void;
+export declare function validateSemanticFactLocator(manifest: SemanticFactManifestV1, locator: {
+    material_ref: string;
+    kind: string;
+    value: string;
+}, label: string): void;
+export declare function validateSemanticFactQuantifier(manifest: SemanticFactManifestV1, fact: SemanticFactManifestV1["facts"][number]): void;
+export declare function validateSemanticFactCrossProduct(rule: SemanticFactManifestV1["condition_rules"][number], axes: Map<string, SemanticFactManifestV1["axis_dispositions"][number]>, conditions: Map<string, SemanticFactManifestV1["conditions"][number]>, exclusions: Map<string, SemanticFactManifestV1["condition_exclusions"][number]>): void;
+export declare function semanticFactCollections(manifest: SemanticFactManifestV1): Record<SemanticFactManifestCollectionName, Array<{
+    key: string;
+}>>;
+export declare function semanticFactCellIdentity(unitRef: string, conditionRef: string, propertyRef: string): string;
+export declare function canonicalSemanticFactCondition(values: Array<{
+    axis_ref: string;
+    value_ref: string;
+}>): string;
+export declare function assertNoSemanticFactParentCycle(key: string, subjects: SemanticFactManifestV1["subjects"]): void;
+export declare function requireSemanticFactBasis(value: {
+    basis_refs: string[];
+}, label: string): void;
+export declare function requireSemanticFactSubset(actual: string[], allowed: string[], code: string, label: string): void;
+export declare function uniqueNonemptySemanticFacts(values: Array<string | number>, label: string): void;
+export declare function uniqueSemanticFacts(values: Array<string | number>, label: string): void;
+export declare function assertSameSemanticFactSet(actual: Array<string | number>, expected: Array<string | number>, label: string): void;
+export declare function semanticFactInvalid(code: string, detail: string): never;

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;