project-tiny-context-harness 0.11.0 → 0.12.0

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

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

@@ -1,3 +0,0 @@
-import type { SemanticFactManifestV1 } from "./semantic-fact-types.js";
-export declare function validateSemanticFactInspectorCensus(manifest: SemanticFactManifestV1, externalFactRefs?: ReadonlySet<string>): void;
-export declare function buildSemanticFactInspectorCensus(manifest: SemanticFactManifestV1): SemanticFactManifestV1["inspector"]["census"];

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

@@ -1,126 +0,0 @@
-import { assertSameSemanticFactSet, requireSemanticFactBasis, semanticFactInvalid, validateSemanticFactLocator, } from "./semantic-fact-policy-primitives.js";
-import { canonicalValueJson, sha256Hex } from "./strict-codec.js";
-export function validateSemanticFactInspectorCensus(manifest, externalFactRefs = new Set()) {
-    const factRefs = new Set([
-        ...manifest.facts.map((item) => item.key),
-        ...externalFactRefs,
-    ]);
-    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");
-}
-export function buildSemanticFactInspectorCensus(manifest) {
-    const factsFor = (predicate) => manifest.facts.filter(predicate).map((item) => item.key);
-    return [...expectedCensusRows(manifest, factsFor).entries()].map(([identity, expectation]) => {
-        const separator = identity.indexOf(":");
-        const kind = identity.slice(0, separator);
-        const key = identity.slice(separator + 1);
-        const basisRefs = censusBasisRefs(kind, expectation.row, expectation.fact_refs, manifest);
-        return {
-            key,
-            kind,
-            locator: {
-                material_ref: manifest.key,
-                kind: "manifest_pointer",
-                value: expectation.pointer,
-            },
-            identity_sha256: sha256Hex(canonicalValueJson(expectation.row)),
-            disposition: expectation.fact_refs.length
-                ? "material_with_facts"
-                : "supporting_only",
-            fact_refs: expectation.fact_refs,
-            basis_refs: basisRefs,
-            rationale: expectation.fact_refs.length
-                ? "This census identity contributes to an exact semantic Fact."
-                : "This identity is explicitly inventoried as supporting or inapplicable.",
-        };
-    });
-}
-function censusBasisRefs(kind, row, factRefs, manifest) {
-    if (row && typeof row === "object" && !Array.isArray(row)) {
-        const record = row;
-        for (const field of ["basis_refs", "source_item_refs"])
-            if (Array.isArray(record[field]) &&
-                record[field].every((item) => typeof item === "string") &&
-                record[field].length)
-                return [...record[field]];
-    }
-    if (kind === "proof_obligation" && factRefs.length) {
-        const fact = manifest.facts.find((item) => item.key === factRefs[0]);
-        if (fact?.source_item_refs.length)
-            return [...fact.source_item_refs];
-    }
-    return [manifest.scope.source_item_refs[0]];
-}
-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

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

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

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

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

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

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

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

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

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

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