project-tiny-context-harness 0.8.4 → 0.8.5

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;
+    };
+}[];

package/dist/lib/semantic-fact-proof-shape.js

@@ -0,0 +1,121 @@
+import { EVIDENCE_CAPABILITIES, PROOF_SURFACES, } from "./long-task-shape-primitives.js";
+import { SEMANTIC_FACT_VALUE_KINDS } from "./semantic-fact-shape-constants.js";
+import { semanticArray, semanticLiteral, semanticNullable, semanticNullableNumber, semanticObject, semanticStableRef, semanticStableRefs, semanticString, } from "./semantic-fact-shape-primitives.js";
+import { parseSemanticFactLocatedValue } from "./semantic-fact-value-shape.js";
+export function parseSemanticFacts(value, label) {
+    return semanticArray(value, label).map((item, index) => {
+        const itemLabel = `${label}[${index}]`;
+        const row = semanticObject(item, itemLabel, [
+            "key",
+            "cell_ref",
+            "outcome_ref",
+            "unit_ref",
+            "family_ref",
+            "condition_ref",
+            "property_ref",
+            "owner_ref",
+            "value_kind",
+            "observation_scope",
+            "observation_sensitivity",
+            "quantifier",
+            "expected",
+            "provenance",
+            "source_item_refs",
+        ]);
+        const quantifier = semanticObject(row.quantifier, `${itemLabel}.quantifier`, ["kind", "minimum", "maximum", "population_ref"]);
+        const provenance = semanticObject(row.provenance, `${itemLabel}.provenance`, ["kind", "authority_ref", "basis_refs", "derivation"]);
+        return {
+            key: semanticStableRef(row.key, `${itemLabel}.key`),
+            cell_ref: semanticStableRef(row.cell_ref, `${itemLabel}.cell_ref`),
+            outcome_ref: semanticStableRef(row.outcome_ref, `${itemLabel}.outcome_ref`),
+            unit_ref: semanticStableRef(row.unit_ref, `${itemLabel}.unit_ref`),
+            family_ref: semanticStableRef(row.family_ref, `${itemLabel}.family_ref`),
+            condition_ref: semanticStableRef(row.condition_ref, `${itemLabel}.condition_ref`),
+            property_ref: semanticStableRef(row.property_ref, `${itemLabel}.property_ref`),
+            owner_ref: semanticStableRef(row.owner_ref, `${itemLabel}.owner_ref`),
+            value_kind: semanticLiteral(row.value_kind, SEMANTIC_FACT_VALUE_KINDS, `${itemLabel}.value_kind`),
+            observation_scope: semanticLiteral(row.observation_scope, [
+                "product_boundary",
+                "service_boundary",
+                "data_boundary",
+                "security_boundary",
+                "operational_boundary",
+                "implementation_structure",
+                "external_boundary",
+            ], `${itemLabel}.observation_scope`),
+            observation_sensitivity: semanticLiteral(row.observation_sensitivity, ["plain", "protected"], `${itemLabel}.observation_sensitivity`),
+            quantifier: {
+                kind: semanticLiteral(quantifier.kind, [
+                    "one",
+                    "all",
+                    "any",
+                    "none",
+                    "exactly",
+                    "at_least",
+                    "at_most",
+                    "range",
+                ], `${itemLabel}.quantifier.kind`),
+                minimum: semanticNullableNumber(quantifier.minimum, `${itemLabel}.quantifier.minimum`),
+                maximum: semanticNullableNumber(quantifier.maximum, `${itemLabel}.quantifier.maximum`),
+                population_ref: semanticNullable(quantifier.population_ref, (entry) => semanticStableRef(entry, `${itemLabel}.quantifier.population_ref`)),
+            },
+            expected: parseSemanticFactLocatedValue(row.expected, `${itemLabel}.expected`),
+            provenance: {
+                kind: semanticLiteral(provenance.kind, [
+                    "direct",
+                    "logically_derived",
+                    "explicitly_delegated",
+                    "evidence_backed_preservation",
+                ], `${itemLabel}.provenance.kind`),
+                authority_ref: semanticStableRef(provenance.authority_ref, `${itemLabel}.provenance.authority_ref`),
+                basis_refs: semanticStableRefs(provenance.basis_refs, `${itemLabel}.provenance.basis_refs`),
+                derivation: semanticNullable(provenance.derivation, (entry) => semanticString(entry, `${itemLabel}.provenance.derivation`)),
+            },
+            source_item_refs: semanticStableRefs(row.source_item_refs, `${itemLabel}.source_item_refs`),
+        };
+    });
+}
+export function parseSemanticFactProofObligations(value, label) {
+    return semanticArray(value, label).map((item, index) => {
+        const itemLabel = `${label}[${index}]`;
+        const row = semanticObject(item, itemLabel, [
+            "key",
+            "fact_ref",
+            "method",
+            "authority",
+            "proof_surface",
+            "evidence_capabilities",
+            "comparison",
+            "oracle_ref",
+            "environment_ref",
+            "observer_refs",
+            "counterfactual",
+        ]);
+        const comparison = semanticObject(row.comparison, `${itemLabel}.comparison`, ["comparator", "mode", "parameters", "tolerance", "mask"]);
+        const counterfactual = semanticObject(row.counterfactual, `${itemLabel}.counterfactual`, ["disposition", "refs", "basis_refs", "rationale"]);
+        return {
+            key: semanticStableRef(row.key, `${itemLabel}.key`),
+            fact_ref: semanticStableRef(row.fact_ref, `${itemLabel}.fact_ref`),
+            method: semanticStableRef(row.method, `${itemLabel}.method`),
+            authority: semanticLiteral(row.authority, ["machine", "external_confirmation"], `${itemLabel}.authority`),
+            proof_surface: semanticLiteral(row.proof_surface, PROOF_SURFACES, `${itemLabel}.proof_surface`),
+            evidence_capabilities: semanticArray(row.evidence_capabilities, `${itemLabel}.evidence_capabilities`).map((entry, capabilityIndex) => semanticLiteral(entry, EVIDENCE_CAPABILITIES, `${itemLabel}.evidence_capabilities[${capabilityIndex}]`)),
+            comparison: {
+                comparator: semanticStableRef(comparison.comparator, `${itemLabel}.comparison.comparator`),
+                mode: semanticLiteral(comparison.mode, ["exact", "tolerance"], `${itemLabel}.comparison.mode`),
+                parameters: parseSemanticFactLocatedValue(comparison.parameters, `${itemLabel}.comparison.parameters`),
+                tolerance: semanticNullable(comparison.tolerance, (entry) => parseSemanticFactLocatedValue(entry, `${itemLabel}.comparison.tolerance`)),
+                mask: semanticNullable(comparison.mask, (entry) => parseSemanticFactLocatedValue(entry, `${itemLabel}.comparison.mask`)),
+            },
+            oracle_ref: semanticStableRef(row.oracle_ref, `${itemLabel}.oracle_ref`),
+            environment_ref: semanticStableRef(row.environment_ref, `${itemLabel}.environment_ref`),
+            observer_refs: semanticStableRefs(row.observer_refs, `${itemLabel}.observer_refs`),
+            counterfactual: {
+                disposition: semanticLiteral(counterfactual.disposition, ["required", "not_applicable", "external"], `${itemLabel}.counterfactual.disposition`),
+                refs: semanticStableRefs(counterfactual.refs, `${itemLabel}.counterfactual.refs`),
+                basis_refs: semanticStableRefs(counterfactual.basis_refs, `${itemLabel}.counterfactual.basis_refs`),
+                rationale: semanticString(counterfactual.rationale, `${itemLabel}.counterfactual.rationale`),
+            },
+        };
+    });
+}

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

@@ -0,0 +1,74 @@
+import type { EvidenceCapabilityV2, ProofSurface } from "./long-task-delivery-types.js";
+import type { SemanticFactAuthorityKind, SemanticFactLocatedValueV1, SemanticFactValueKind } from "./semantic-fact-base-types.js";
+export interface SemanticFactV1 {
+    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: SemanticFactValueKind;
+    observation_scope: "product_boundary" | "service_boundary" | "data_boundary" | "security_boundary" | "operational_boundary" | "implementation_structure" | "external_boundary";
+    observation_sensitivity: "plain" | "protected";
+    quantifier: {
+        kind: "one" | "all" | "any" | "none" | "exactly" | "at_least" | "at_most" | "range";
+        minimum: number | null;
+        maximum: number | null;
+        population_ref: string | null;
+    };
+    expected: SemanticFactLocatedValueV1;
+    provenance: {
+        kind: SemanticFactAuthorityKind;
+        authority_ref: string;
+        basis_refs: string[];
+        derivation: string | null;
+    };
+    source_item_refs: string[];
+}
+export interface SemanticFactOracleV1 {
+    key: string;
+    trust: "frozen_executable" | "named_external_tcb";
+    identity: string;
+    version: string;
+    sha256: string | null;
+    capabilities: string[];
+}
+export interface SemanticFactEnvironmentV1 {
+    key: string;
+    identity: string;
+    definition: SemanticFactLocatedValueV1;
+}
+export interface SemanticFactProofObligationV1 {
+    key: string;
+    fact_ref: string;
+    method: string;
+    authority: "machine" | "external_confirmation";
+    proof_surface: ProofSurface;
+    evidence_capabilities: EvidenceCapabilityV2[];
+    comparison: {
+        comparator: string;
+        mode: "exact" | "tolerance";
+        parameters: SemanticFactLocatedValueV1;
+        tolerance: SemanticFactLocatedValueV1 | null;
+        mask: SemanticFactLocatedValueV1 | null;
+    };
+    oracle_ref: string;
+    environment_ref: string;
+    observer_refs: string[];
+    counterfactual: {
+        disposition: "required" | "not_applicable" | "external";
+        refs: string[];
+        basis_refs: string[];
+        rationale: string;
+    };
+}
+export interface SemanticFactBlockerV1 {
+    key: string;
+    kind: "decision_required" | "unavailable" | "conflict" | "unreadable";
+    affected_refs: string[];
+    source_item_refs: string[];
+    owner: string;
+    resolution: string;
+}

package/dist/lib/semantic-fact-proof-types.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,29 @@
+export declare function parseSemanticFactPropertyDispositions(value: unknown, label: string): {
+    key: string;
+    family_ref: string;
+    property: string;
+    standard: boolean;
+    value_kind: "boolean" | "custom" | "decision_table" | "digest" | "duration" | "enum" | "formula" | "number" | "object" | "ordered_list" | "range" | "rate" | "ratio" | "relation" | "schema" | "set" | "string" | "timestamp" | "trace";
+    required_methods: string[];
+    required_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")[];
+    applicable_unit_refs: string[];
+    not_applicable_unit_refs: string[];
+    decision_required_unit_refs: string[];
+    unavailable_unit_refs: string[];
+    condition_refs: string[];
+    source_item_refs: string[];
+    basis_refs: string[];
+    rationale: string;
+}[];
+export declare function parseSemanticFactCells(value: unknown, label: string): {
+    key: string;
+    outcome_ref: string;
+    unit_ref: string;
+    condition_ref: string;
+    property_ref: string;
+    disposition: "decision_required" | "not_applicable" | "specified" | "unavailable";
+    fact_ref: string | null;
+    source_item_refs: string[];
+    basis_refs: string[];
+    rationale: string;
+}[];