project-tiny-context-harness 0.11.0 → 0.12.0

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

@@ -1,75 +0,0 @@
-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

@@ -1,3 +0,0 @@
-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

@@ -1,84 +0,0 @@
-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

@@ -1,4 +0,0 @@
-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

@@ -1,103 +0,0 @@
-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

@@ -1,17 +0,0 @@
-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, externalFactRefs?: ReadonlySet<string>): 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

@@ -1,41 +0,0 @@
-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, externalFactRefs = new Set()) {
-    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, externalFactRefs);
-    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

@@ -1,51 +0,0 @@
-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: ("actual_provenance" | "boundary_invocation" | "cross_surface_consistency" | "data_state" | "design_conformance" | "design_method" | "design_symbolic_certificate" | "distinct_identity" | "durable_readback" | "external_side_effect" | "failure_injection" | "input_variation" | "interaction_trace" | "population_coverage" | "presence" | "recovery" | "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

@@ -1,121 +0,0 @@
-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

@@ -1,74 +0,0 @@
-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

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

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

@@ -1,29 +0,0 @@
-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: ("actual_provenance" | "boundary_invocation" | "cross_surface_consistency" | "data_state" | "design_conformance" | "design_method" | "design_symbolic_certificate" | "distinct_identity" | "durable_readback" | "external_side_effect" | "failure_injection" | "input_variation" | "interaction_trace" | "population_coverage" | "presence" | "recovery" | "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;
-}[];