project-tiny-context-harness 0.8.3 → 0.8.5

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

@@ -0,0 +1,135 @@
+import { parseSemanticFactAxisDispositions, parseSemanticFactConditionExclusions, parseSemanticFactConditionRules, parseSemanticFactConditions, } from "./semantic-fact-condition-shape.js";
+import { parseSemanticFactCensus, parseSemanticFactFamilyDispositions, parseSemanticFactInputs, } from "./semantic-fact-input-shape.js";
+import { SEMANTIC_FACT_MANIFEST_COLLECTIONS, } from "./semantic-fact-types.js";
+import { parseSemanticFactCells, parseSemanticFactPropertyDispositions, } from "./semantic-fact-property-shape.js";
+import { parseSemanticFactProofObligations, parseSemanticFacts, } from "./semantic-fact-proof-shape.js";
+import { semanticArray, semanticInteger, semanticLiteral, semanticNullableSha256, semanticObject, semanticSha256, semanticStableRef, semanticStableRefs, semanticString, } from "./semantic-fact-shape-primitives.js";
+import { parseSemanticFactBlockers, parseSemanticFactEnvironments, parseSemanticFactOracles, } from "./semantic-fact-support-shape.js";
+import { parseSemanticFactPopulations, parseSemanticFactRelations, parseSemanticFactSubjects, } from "./semantic-fact-unit-shape.js";
+import { parseStrictYaml } from "./strict-codec.js";
+export { parseSemanticFactLocatedValue } from "./semantic-fact-value-shape.js";
+export function parseSemanticFactManifestYaml(content) {
+    return parseSemanticFactManifestShape(parseStrictYaml(content));
+}
+export function parseSemanticFactManifestShape(value) {
+    const label = "semantic_fact_manifest";
+    const root = semanticObject(value, label, [
+        "schema_version",
+        "key",
+        "scope",
+        "inspector",
+        "generation",
+        "inputs",
+        "family_dispositions",
+        "subjects",
+        "relations",
+        "populations",
+        "axis_dispositions",
+        "condition_rules",
+        "conditions",
+        "condition_exclusions",
+        "property_dispositions",
+        "fact_cells",
+        "facts",
+        "proof_obligations",
+        "oracles",
+        "environments",
+        "blockers",
+    ]);
+    const scope = semanticObject(root.scope, `${label}.scope`, [
+        "outcome_refs",
+        "source_item_refs",
+        "exclusions",
+    ]);
+    const inspector = semanticObject(root.inspector, `${label}.inspector`, [
+        "trust",
+        "identity",
+        "version",
+        "implementation_sha256",
+        "capabilities",
+        "traversal",
+        "dynamic_discovery",
+        "census",
+    ]);
+    const generation = semanticObject(root.generation, `${label}.generation`, [
+        "strategy",
+        "sampling",
+        "truncation",
+        "chunk_count",
+        "chunk_indexes",
+        "collections",
+    ]);
+    return {
+        schema_version: semanticLiteral(root.schema_version, ["semantic-fact-manifest-v1"], `${label}.schema_version`),
+        key: semanticStableRef(root.key, `${label}.key`),
+        scope: {
+            outcome_refs: semanticStableRefs(scope.outcome_refs, `${label}.scope.outcome_refs`),
+            source_item_refs: semanticStableRefs(scope.source_item_refs, `${label}.scope.source_item_refs`),
+            exclusions: semanticArray(scope.exclusions, `${label}.scope.exclusions`).map((item, index) => {
+                const itemLabel = `${label}.scope.exclusions[${index}]`;
+                const row = semanticObject(item, itemLabel, [
+                    "key",
+                    "statement",
+                    "affected_refs",
+                    "source_item_refs",
+                    "basis_refs",
+                    "rationale",
+                ]);
+                return {
+                    key: semanticStableRef(row.key, `${itemLabel}.key`),
+                    statement: semanticString(row.statement, `${itemLabel}.statement`),
+                    affected_refs: semanticStableRefs(row.affected_refs, `${itemLabel}.affected_refs`),
+                    source_item_refs: semanticStableRefs(row.source_item_refs, `${itemLabel}.source_item_refs`),
+                    basis_refs: semanticStableRefs(row.basis_refs, `${itemLabel}.basis_refs`),
+                    rationale: semanticString(row.rationale, `${itemLabel}.rationale`),
+                };
+            }),
+        },
+        inspector: {
+            trust: semanticLiteral(inspector.trust, ["frozen_executable", "named_external_tcb"], `${label}.inspector.trust`),
+            identity: semanticString(inspector.identity, `${label}.inspector.identity`),
+            version: semanticString(inspector.version, `${label}.inspector.version`),
+            implementation_sha256: semanticNullableSha256(inspector.implementation_sha256, `${label}.inspector.implementation_sha256`),
+            capabilities: semanticStableRefs(inspector.capabilities, `${label}.inspector.capabilities`),
+            traversal: semanticLiteral(inspector.traversal, ["complete_enumeration"], `${label}.inspector.traversal`),
+            dynamic_discovery: semanticLiteral(inspector.dynamic_discovery, ["fully_enumerated"], `${label}.inspector.dynamic_discovery`),
+            census: parseSemanticFactCensus(inspector.census, `${label}.inspector.census`),
+        },
+        generation: {
+            strategy: semanticLiteral(generation.strategy, ["complete_explicit"], `${label}.generation.strategy`),
+            sampling: semanticLiteral(generation.sampling, ["forbidden"], `${label}.generation.sampling`),
+            truncation: semanticLiteral(generation.truncation, ["forbidden"], `${label}.generation.truncation`),
+            chunk_count: semanticInteger(generation.chunk_count, `${label}.generation.chunk_count`, 1),
+            chunk_indexes: semanticArray(generation.chunk_indexes, `${label}.generation.chunk_indexes`).map((item, index) => semanticInteger(item, `${label}.generation.chunk_indexes[${index}]`, 0)),
+            collections: semanticArray(generation.collections, `${label}.generation.collections`).map((item, index) => {
+                const itemLabel = `${label}.generation.collections[${index}]`;
+                const row = semanticObject(item, itemLabel, [
+                    "name",
+                    "expected_count",
+                    "identity_sha256",
+                ]);
+                return {
+                    name: semanticLiteral(row.name, SEMANTIC_FACT_MANIFEST_COLLECTIONS, `${itemLabel}.name`),
+                    expected_count: semanticInteger(row.expected_count, `${itemLabel}.expected_count`),
+                    identity_sha256: semanticSha256(row.identity_sha256, `${itemLabel}.identity_sha256`),
+                };
+            }),
+        },
+        inputs: parseSemanticFactInputs(root.inputs, `${label}.inputs`),
+        family_dispositions: parseSemanticFactFamilyDispositions(root.family_dispositions, `${label}.family_dispositions`),
+        subjects: parseSemanticFactSubjects(root.subjects, `${label}.subjects`),
+        relations: parseSemanticFactRelations(root.relations, `${label}.relations`),
+        populations: parseSemanticFactPopulations(root.populations, `${label}.populations`),
+        axis_dispositions: parseSemanticFactAxisDispositions(root.axis_dispositions, `${label}.axis_dispositions`),
+        condition_rules: parseSemanticFactConditionRules(root.condition_rules, `${label}.condition_rules`),
+        conditions: parseSemanticFactConditions(root.conditions, `${label}.conditions`),
+        condition_exclusions: parseSemanticFactConditionExclusions(root.condition_exclusions, `${label}.condition_exclusions`),
+        property_dispositions: parseSemanticFactPropertyDispositions(root.property_dispositions, `${label}.property_dispositions`),
+        fact_cells: parseSemanticFactCells(root.fact_cells, `${label}.fact_cells`),
+        facts: parseSemanticFacts(root.facts, `${label}.facts`),
+        proof_obligations: parseSemanticFactProofObligations(root.proof_obligations, `${label}.proof_obligations`),
+        oracles: parseSemanticFactOracles(root.oracles, `${label}.oracles`),
+        environments: parseSemanticFactEnvironments(root.environments, `${label}.environments`),
+        blockers: parseSemanticFactBlockers(root.blockers, `${label}.blockers`),
+    };
+}

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

@@ -0,0 +1,58 @@
+import type { SemanticFactAxisDispositionV1, SemanticFactCensusEntryV1, SemanticFactCellV1, SemanticFactConditionExclusionV1, SemanticFactConditionRuleV1, SemanticFactConditionV1, SemanticFactFamilyDispositionV1, SemanticFactInputV1, SemanticFactPopulationV1, SemanticFactPropertyDispositionV1, SemanticFactRelationV1, SemanticFactSubjectV1 } from "./semantic-fact-inventory-types.js";
+import type { SemanticFactBlockerV1, SemanticFactEnvironmentV1, SemanticFactOracleV1, SemanticFactProofObligationV1, SemanticFactV1 } from "./semantic-fact-proof-types.js";
+export declare const SEMANTIC_FACT_MANIFEST_COLLECTIONS: readonly ["inputs", "inspector_census", "family_dispositions", "subjects", "relations", "populations", "axis_dispositions", "condition_rules", "conditions", "condition_exclusions", "property_dispositions", "fact_cells", "facts", "proof_obligations", "oracles", "environments", "blockers"];
+export type SemanticFactManifestCollectionName = (typeof SEMANTIC_FACT_MANIFEST_COLLECTIONS)[number];
+export interface SemanticFactManifestV1 {
+    schema_version: "semantic-fact-manifest-v1";
+    key: string;
+    scope: {
+        outcome_refs: string[];
+        source_item_refs: string[];
+        exclusions: Array<{
+            key: string;
+            statement: string;
+            affected_refs: string[];
+            source_item_refs: string[];
+            basis_refs: string[];
+            rationale: string;
+        }>;
+    };
+    inspector: {
+        trust: "frozen_executable" | "named_external_tcb";
+        identity: string;
+        version: string;
+        implementation_sha256: string | null;
+        capabilities: string[];
+        traversal: "complete_enumeration";
+        dynamic_discovery: "fully_enumerated";
+        census: SemanticFactCensusEntryV1[];
+    };
+    generation: {
+        strategy: "complete_explicit";
+        sampling: "forbidden";
+        truncation: "forbidden";
+        chunk_count: number;
+        chunk_indexes: number[];
+        collections: Array<{
+            name: SemanticFactManifestCollectionName;
+            expected_count: number;
+            identity_sha256: string;
+        }>;
+    };
+    inputs: SemanticFactInputV1[];
+    family_dispositions: SemanticFactFamilyDispositionV1[];
+    subjects: SemanticFactSubjectV1[];
+    relations: SemanticFactRelationV1[];
+    populations: SemanticFactPopulationV1[];
+    axis_dispositions: SemanticFactAxisDispositionV1[];
+    condition_rules: SemanticFactConditionRuleV1[];
+    conditions: SemanticFactConditionV1[];
+    condition_exclusions: SemanticFactConditionExclusionV1[];
+    property_dispositions: SemanticFactPropertyDispositionV1[];
+    fact_cells: SemanticFactCellV1[];
+    facts: SemanticFactV1[];
+    proof_obligations: SemanticFactProofObligationV1[];
+    oracles: SemanticFactOracleV1[];
+    environments: SemanticFactEnvironmentV1[];
+    blockers: SemanticFactBlockerV1[];
+}

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

@@ -0,0 +1,19 @@
+export const SEMANTIC_FACT_MANIFEST_COLLECTIONS = [
+    "inputs",
+    "inspector_census",
+    "family_dispositions",
+    "subjects",
+    "relations",
+    "populations",
+    "axis_dispositions",
+    "condition_rules",
+    "conditions",
+    "condition_exclusions",
+    "property_dispositions",
+    "fact_cells",
+    "facts",
+    "proof_obligations",
+    "oracles",
+    "environments",
+    "blockers",
+];

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

@@ -0,0 +1,8 @@
+import { type SemanticFactManifestV1 } from "./semantic-fact-types.js";
+export declare function validateSemanticFactInspector(manifest: SemanticFactManifestV1): void;
+export declare function validateSemanticFactSourceLineage(manifest: SemanticFactManifestV1): void;
+export declare function semanticFactCollectionIdentity(rows: Array<{
+    key: string;
+}>): string;
+export declare function validateSemanticFactUniqueIdentities(manifest: SemanticFactManifestV1): void;
+export declare function validateSemanticFactGeneration(manifest: SemanticFactManifestV1): void;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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