project-tiny-context-harness 0.8.4 → 0.8.6

package/dist/lib/design-resource-handoff-validation-coverage.js

@@ -1,88 +1,147 @@
-import { DESIGN_RESOURCE_EVIDENCE_BY_DIMENSION, DESIGN_RESOURCE_METHODS_BY_DIMENSION, } from "./design-resource-handoff-policy.js";
-import { DESIGN_RESOURCE_DIMENSIONS, } from "./design-resource-handoff-types.js";
+import { DESIGN_RESOURCE_METHODS_BY_DIMENSION } from "./design-resource-handoff-policy.js";
 import { invalidDesignResourceHandoff, requireDesignSourceItemKind, requireKnownDesignResourceRef, requireNonemptyDesignResourceValues, requireUniqueDesignResourceValues, } from "./design-resource-handoff-validation-primitives.js";
 export function validateDesignResourceCoverage(handoff, subjects, targets, conditions, evidence, facts, sourceItems) {
-    const cells = new Set();
+    const variations = new Map(handoff.variations.map((item) => [item.key, item]));
+    const properties = new Map(handoff.properties.map((item) => [item.key, item]));
+    const factCells = new Map(handoff.fact_cells.map((item) => [item.key, item]));
+    const proofs = new Map(handoff.proof_obligations.map((item) => [item.key, item]));
+    const referencedCells = new Set();
     const referencedFacts = new Set();
-    const unresolved = [];
+    const referencedProofs = new Set();
     for (const row of handoff.coverage) {
-        requireNonemptyDesignResourceValues(row.subject_refs, `coverage_subject_refs_required:${row.key}`);
-        requireNonemptyDesignResourceValues(row.source_item_refs, `coverage_source_item_refs_required:${row.key}`);
         for (const [name, values] of [
             ["subject_ref", row.subject_refs],
             ["target_ref", row.target_refs],
             ["condition_ref", row.condition_refs],
+            ["variation_ref", row.variation_refs],
+            ["property_ref", row.property_refs],
             ["evidence_ref", row.evidence_refs],
+            ["fact_cell_ref", row.fact_cell_refs],
             ["fact_ref", row.fact_refs],
+            ["proof_obligation_ref", row.proof_obligation_refs],
             ["source_item_ref", row.source_item_refs],
             ["verification_method", row.verification_methods],
         ])
             requireUniqueDesignResourceValues(values, `coverage_${name}_duplicate:${row.key}`);
+        for (const [name, values] of [
+            ["subject_refs", row.subject_refs],
+            ["target_refs", row.target_refs],
+            ["condition_refs", row.condition_refs],
+            ["variation_refs", row.variation_refs],
+            ["property_refs", row.property_refs],
+            ["fact_cell_refs", row.fact_cell_refs],
+            ["source_item_refs", row.source_item_refs],
+        ])
+            requireNonemptyDesignResourceValues(values, `coverage_${name}_required:${row.key}`);
         for (const ref of row.subject_refs)
             requireKnownDesignResourceRef(subjects, ref, "subject");
+        for (const ref of row.target_refs)
+            requireKnownDesignResourceRef(targets, ref, "target");
+        for (const ref of row.condition_refs)
+            requireKnownDesignResourceRef(conditions, ref, "condition");
+        for (const ref of row.variation_refs)
+            requireKnownDesignResourceRef(variations, ref, "variation");
+        for (const ref of row.property_refs)
+            requireKnownDesignResourceRef(properties, ref, "property");
         for (const ref of row.source_item_refs) {
             requireKnownDesignResourceRef(sourceItems, ref, "source_item");
             requireDesignSourceItemKind(sourceItems, ref);
         }
-        validateCoverageApplicability(row, handoff, targets, conditions, cells);
+        const cells = row.fact_cell_refs.map((ref) => {
+            requireKnownDesignResourceRef(factCells, ref, "fact_cell");
+            if (referencedCells.has(ref))
+                invalidDesignResourceHandoff("coverage_fact_cell_ref_duplicate", `${row.key}:${ref}`);
+            referencedCells.add(ref);
+            return factCells.get(ref);
+        });
+        for (const cell of cells) {
+            const property = properties.get(cell.property_ref);
+            if (property.dimension !== row.dimension ||
+                cell.disposition !== row.disposition ||
+                !row.subject_refs.includes(cell.subject_ref) ||
+                !row.target_refs.includes(cell.target_ref) ||
+                !row.condition_refs.includes(cell.condition_ref) ||
+                !row.variation_refs.includes(cell.variation_ref) ||
+                !row.property_refs.includes(cell.property_ref))
+                invalidDesignResourceHandoff("coverage_fact_cell_mismatch", `${row.key}:${cell.key}`);
+        }
+        assertSameSet(row.subject_refs, cells.map((cell) => cell.subject_ref), "coverage_subject_refs_mismatch", row.key);
+        assertSameSet(row.target_refs, cells.map((cell) => cell.target_ref), "coverage_target_refs_mismatch", row.key);
+        assertSameSet(row.condition_refs, cells.map((cell) => cell.condition_ref), "coverage_condition_refs_mismatch", row.key);
+        assertSameSet(row.variation_refs, cells.map((cell) => cell.variation_ref), "coverage_variation_refs_mismatch", row.key);
+        assertSameSet(row.property_refs, cells.map((cell) => cell.property_ref), "coverage_property_refs_mismatch", row.key);
         if (row.disposition === "covered")
-            validateCoveredRow(row, handoff, targets, conditions, evidence, facts, referencedFacts);
-        else if (row.disposition === "decision_required" ||
-            row.disposition === "unavailable")
-            unresolved.push(row.key);
+            validateCoveredRow(row, cells, evidence, facts, proofs, referencedFacts, referencedProofs);
         else
-            validateNoncoveredRow(row);
+            validateNoncoveredRow(row, cells);
     }
-    for (const subject of handoff.subjects)
-        for (const targetRef of subject.target_refs) {
-            const target = targets.get(targetRef);
-            for (const conditionRef of target.condition_refs)
-                for (const dimension of DESIGN_RESOURCE_DIMENSIONS) {
-                    const cell = coverageCell(subject.key, targetRef, conditionRef, dimension);
-                    if (!cells.has(cell))
-                        invalidDesignResourceHandoff("coverage_cell_missing", `${subject.key}:${targetRef}:${conditionRef}:${dimension}`);
-                }
-        }
-    if (unresolved.length)
-        invalidDesignResourceHandoff("unresolved_coverage", unresolved.sort().join(","));
-    for (const fact of handoff.facts)
-        if (!referencedFacts.has(fact.key))
-            invalidDesignResourceHandoff("design_resource_fact_unreferenced", fact.key);
+    assertSameSet([...referencedCells], handoff.fact_cells.map((cell) => cell.key), "coverage_fact_cell_set_mismatch", "handoff");
+    assertSameSet([...referencedFacts], handoff.facts.map((fact) => fact.key), "coverage_fact_set_mismatch", "handoff");
+    assertSameSet([...referencedProofs], handoff.proof_obligations.map((proof) => proof.key), "coverage_proof_obligation_set_mismatch", "handoff");
 }
-function validateCoverageApplicability(row, handoff, targets, conditions, cells) {
-    requireNonemptyDesignResourceValues(row.target_refs, `coverage_target_refs_required:${row.key}`);
-    requireNonemptyDesignResourceValues(row.condition_refs, `coverage_condition_refs_required:${row.key}`);
-    for (const targetRef of row.target_refs)
-        requireKnownDesignResourceRef(targets, targetRef, "target");
-    for (const conditionRef of row.condition_refs)
-        requireKnownDesignResourceRef(conditions, conditionRef, "condition");
-    const subjects = new Map(handoff.subjects.map((item) => [item.key, item]));
-    for (const subjectRef of row.subject_refs) {
-        const subject = subjects.get(subjectRef);
-        for (const targetRef of row.target_refs) {
-            if (!subject.target_refs.includes(targetRef))
-                invalidDesignResourceHandoff("coverage_target_outside_subject", `${row.key}:${subjectRef}:${targetRef}`);
-            const target = targets.get(targetRef);
-            for (const conditionRef of row.condition_refs) {
-                if (!target.condition_refs.includes(conditionRef))
-                    invalidDesignResourceHandoff("coverage_condition_outside_target", `${row.key}:${targetRef}:${conditionRef}`);
-                const cell = coverageCell(subjectRef, targetRef, conditionRef, row.dimension);
-                if (cells.has(cell))
-                    invalidDesignResourceHandoff("coverage_cell_duplicate", `${subjectRef}:${targetRef}:${conditionRef}:${row.dimension}`);
-                cells.add(cell);
-            }
-        }
+function validateCoveredRow(row, cells, evidence, facts, proofs, referencedFacts, referencedProofs) {
+    for (const [name, values] of [
+        ["evidence_refs", row.evidence_refs],
+        ["fact_refs", row.fact_refs],
+        ["proof_obligation_refs", row.proof_obligation_refs],
+        ["verification_methods", row.verification_methods],
+    ])
+        requireNonemptyDesignResourceValues(values, `coverage_${name}_required:${row.key}`);
+    const expectedFactRefs = cells.map((cell) => cell.fact_ref);
+    assertSameSet(row.fact_refs, expectedFactRefs, "coverage_fact_refs_mismatch", row.key);
+    for (const ref of row.fact_refs) {
+        requireKnownDesignResourceRef(facts, ref, "fact");
+        if (referencedFacts.has(ref))
+            invalidDesignResourceHandoff("coverage_fact_ref_duplicate", `${row.key}:${ref}`);
+        referencedFacts.add(ref);
     }
+    const localFacts = row.fact_refs.map((ref) => facts.get(ref));
+    for (const ref of row.evidence_refs)
+        requireKnownDesignResourceRef(evidence, ref, "evidence");
+    assertSameSet(row.evidence_refs, localFacts.flatMap((fact) => fact.evidence_refs), "coverage_fact_evidence_refs_mismatch", row.key);
+    assertSameSet(row.source_item_refs, localFacts.flatMap((fact) => fact.source_item_refs), "coverage_fact_source_item_refs_mismatch", row.key);
+    const localProofs = row.proof_obligation_refs.map((ref) => {
+        requireKnownDesignResourceRef(proofs, ref, "proof_obligation");
+        if (referencedProofs.has(ref))
+            invalidDesignResourceHandoff("coverage_proof_obligation_ref_duplicate", `${row.key}:${ref}`);
+        referencedProofs.add(ref);
+        return proofs.get(ref);
+    });
+    assertSameSet(row.proof_obligation_refs, [...proofs.values()]
+        .filter((proof) => row.fact_refs.includes(proof.fact_ref))
+        .map((proof) => proof.key), "coverage_proof_obligation_refs_mismatch", row.key);
+    assertSameSet(row.verification_methods, localProofs.map((proof) => proof.method), "coverage_verification_methods_mismatch", row.key);
+    const allowedMethods = new Set(DESIGN_RESOURCE_METHODS_BY_DIMENSION[row.dimension]);
+    for (const method of row.verification_methods)
+        if (!allowedMethods.has(method))
+            invalidDesignResourceHandoff("coverage_verification_method_incompatible", `${row.key}:${row.dimension}:${method}`);
 }
-function coverageCell(subjectRef, targetRef, conditionRef, dimension) {
-    return `${subjectRef}\0${targetRef}\0${conditionRef}\0${dimension}`;
+function validateNoncoveredRow(row, cells) {
+    for (const [name, values] of [
+        ["evidence_refs", row.evidence_refs],
+        ["fact_refs", row.fact_refs],
+        ["proof_obligation_refs", row.proof_obligation_refs],
+        ["verification_methods", row.verification_methods],
+    ])
+        if (values.length)
+            invalidDesignResourceHandoff("noncovered_binding_forbidden", `${row.key}:${row.disposition}:${name}`);
+    assertSameSet(row.source_item_refs, cells.flatMap((cell) => cell.source_item_refs), "coverage_noncovered_source_item_refs_mismatch", row.key);
+    if (row.disposition === "decision_required" ||
+        row.disposition === "unavailable")
+        invalidDesignResourceHandoff("unresolved_coverage", row.key);
 }
 export function validateDesignResourceBlockers(handoff, subjects, targets, sourceItems) {
+    const cells = new Map(handoff.fact_cells.map((item) => [item.key, item]));
+    const facts = new Map(handoff.facts.map((item) => [item.key, item]));
+    const proofs = new Map(handoff.proof_obligations.map((item) => [item.key, item]));
     for (const blocker of handoff.acceptance_blockers) {
         for (const [name, values] of [
             ["target_refs", blocker.target_refs],
             ["subject_refs", blocker.subject_refs],
             ["dimensions", blocker.dimensions],
+            ["fact_cell_refs", blocker.fact_cell_refs],
+            ["fact_refs", blocker.fact_refs],
+            ["proof_obligation_refs", blocker.proof_obligation_refs],
             ["source_item_refs", blocker.source_item_refs],
             ["verification_methods", blocker.verification_methods],
             ["required_capabilities", blocker.required_capabilities],
@@ -94,6 +153,12 @@ export function validateDesignResourceBlockers(handoff, subjects, targets, sourc
             requireKnownDesignResourceRef(targets, ref, "target");
         for (const ref of blocker.subject_refs)
             requireKnownDesignResourceRef(subjects, ref, "subject");
+        for (const ref of blocker.fact_cell_refs)
+            requireKnownDesignResourceRef(cells, ref, "fact_cell");
+        for (const ref of blocker.fact_refs)
+            requireKnownDesignResourceRef(facts, ref, "fact");
+        for (const ref of blocker.proof_obligation_refs)
+            requireKnownDesignResourceRef(proofs, ref, "proof_obligation");
         for (const ref of blocker.source_item_refs) {
             requireKnownDesignResourceRef(sourceItems, ref, "source_item");
             requireDesignSourceItemKind(sourceItems, ref);
@@ -101,23 +166,32 @@ export function validateDesignResourceBlockers(handoff, subjects, targets, sourc
         for (const dimension of blocker.dimensions)
             if (!blocker.verification_methods.some((method) => DESIGN_RESOURCE_METHODS_BY_DIMENSION[dimension].includes(method)))
                 invalidDesignResourceHandoff("acceptance_blocker_dimension_method_missing", `${blocker.key}:${dimension}`);
-        const matchedCoverage = handoff.coverage.filter((row) => row.disposition === "covered" &&
-            blocker.target_refs.some((ref) => row.target_refs.includes(ref)) &&
-            blocker.subject_refs.some((ref) => row.subject_refs.includes(ref)) &&
-            blocker.dimensions.includes(row.dimension));
-        for (const ref of blocker.source_item_refs)
-            if (!matchedCoverage.some((row) => row.source_item_refs.includes(ref)))
-                invalidDesignResourceHandoff("acceptance_blocker_source_item_without_coverage", `${blocker.key}:${ref}`);
-        for (const method of blocker.verification_methods)
-            if (!matchedCoverage.some((row) => row.verification_methods.includes(method)))
-                invalidDesignResourceHandoff("acceptance_blocker_method_without_coverage", `${blocker.key}:${method}`);
+        for (const ref of blocker.fact_refs)
+            if (!blocker.fact_cell_refs.includes(facts.get(ref).cell_ref) ||
+                !blocker.subject_refs.includes(facts.get(ref).subject_ref) ||
+                !blocker.target_refs.includes(facts.get(ref).target_ref))
+                invalidDesignResourceHandoff("acceptance_blocker_fact_scope_mismatch", `${blocker.key}:${ref}`);
+        for (const ref of blocker.proof_obligation_refs) {
+            const proof = proofs.get(ref);
+            if (!blocker.fact_refs.includes(proof.fact_ref) ||
+                !blocker.verification_methods.includes(proof.method))
+                invalidDesignResourceHandoff("acceptance_blocker_proof_scope_mismatch", `${blocker.key}:${ref}`);
+        }
     }
+    if (handoff.acceptance_blockers.length)
+        invalidDesignResourceHandoff("acceptance_blockers_unresolved", handoff.acceptance_blockers.map((item) => item.key).join(","));
 }
 export function validateDesignResourceReachability(handoff) {
     const targetResources = new Set(handoff.targets.flatMap((target) => target.resource_refs));
     const targetConditions = new Set(handoff.targets.flatMap((target) => target.condition_refs));
     const coverageTargets = new Set(handoff.coverage.flatMap((row) => row.target_refs));
     const coverageEvidence = new Set(handoff.coverage.flatMap((row) => row.evidence_refs));
+    const lineageRefs = new Set(handoff.facts.flatMap((fact) => [
+        ...fact.lineage.token_chain_refs,
+        ...fact.lineage.override_chain_refs,
+    ]));
+    const oracleRefs = new Set(handoff.proof_obligations.map((proof) => proof.oracle_ref));
+    const environmentRefs = new Set(handoff.proof_obligations.map((proof) => proof.environment_ref));
     for (const resource of handoff.resources)
         if (!targetResources.has(resource.key))
             invalidDesignResourceHandoff("resource_unreferenced", resource.key);
@@ -130,62 +204,15 @@ export function validateDesignResourceReachability(handoff) {
     for (const item of handoff.evidence)
         if (!coverageEvidence.has(item.key))
             invalidDesignResourceHandoff("evidence_unreferenced", item.key);
-}
-function validateCoveredRow(row, handoff, targets, conditions, evidence, facts, referencedFacts) {
-    for (const [name, values] of [
-        ["target_refs", row.target_refs],
-        ["condition_refs", row.condition_refs],
-        ["evidence_refs", row.evidence_refs],
-        ["fact_refs", row.fact_refs],
-        ["verification_methods", row.verification_methods],
-    ])
-        requireNonemptyDesignResourceValues(values, `coverage_${name}_required:${row.key}`);
-    for (const ref of row.target_refs)
-        requireKnownDesignResourceRef(targets, ref, "target");
-    for (const ref of row.condition_refs)
-        requireKnownDesignResourceRef(conditions, ref, "condition");
-    for (const ref of row.evidence_refs)
-        requireKnownDesignResourceRef(evidence, ref, "evidence");
-    for (const ref of row.fact_refs) {
-        requireKnownDesignResourceRef(facts, ref, "fact");
-        if (referencedFacts.has(ref))
-            invalidDesignResourceHandoff("coverage_fact_ref_duplicate", `${row.key}:${ref}`);
-        referencedFacts.add(ref);
-    }
-    const allowedEvidence = new Set(DESIGN_RESOURCE_EVIDENCE_BY_DIMENSION[row.dimension]);
-    const allowedMethods = new Set(DESIGN_RESOURCE_METHODS_BY_DIMENSION[row.dimension]);
-    for (const ref of row.evidence_refs) {
-        const item = evidence.get(ref);
-        if (!allowedEvidence.has(item.kind))
-            invalidDesignResourceHandoff("coverage_evidence_kind_incompatible", `${row.key}:${row.dimension}:${item.key}:${item.kind}`);
-    }
-    for (const method of row.verification_methods)
-        if (!allowedMethods.has(method))
-            invalidDesignResourceHandoff("coverage_verification_method_incompatible", `${row.key}:${row.dimension}:${method}`);
-    const expectedFacts = handoff.facts.filter((fact) => fact.dimension === row.dimension &&
-        row.subject_refs.includes(fact.subject_ref) &&
-        row.target_refs.includes(fact.target_ref) &&
-        row.condition_refs.includes(fact.condition_ref));
-    assertSameSet(row.fact_refs, expectedFacts.map((fact) => fact.key), "coverage_fact_refs_mismatch", row.key);
-    assertSameSet(row.evidence_refs, expectedFacts.flatMap((fact) => fact.evidence_refs), "coverage_fact_evidence_refs_mismatch", row.key);
-    assertSameSet(row.source_item_refs, expectedFacts.flatMap((fact) => fact.source_item_refs), "coverage_fact_source_item_refs_mismatch", row.key);
-    assertSameSet(row.verification_methods, expectedFacts.map((fact) => fact.verification_method), "coverage_fact_verification_methods_mismatch", row.key);
-    for (const subjectRef of row.subject_refs)
-        for (const targetRef of row.target_refs)
-            for (const conditionRef of row.condition_refs)
-                if (!expectedFacts.some((fact) => fact.subject_ref === subjectRef &&
-                    fact.target_ref === targetRef &&
-                    fact.condition_ref === conditionRef))
-                    invalidDesignResourceHandoff("coverage_cell_without_fact", `${row.key}:${subjectRef}:${targetRef}:${conditionRef}`);
-}
-function validateNoncoveredRow(row) {
-    for (const [name, values] of [
-        ["evidence_refs", row.evidence_refs],
-        ["fact_refs", row.fact_refs],
-        ["verification_methods", row.verification_methods],
-    ])
-        if (values.length)
-            invalidDesignResourceHandoff("noncovered_binding_forbidden", `${row.key}:${row.disposition}:${name}`);
+    for (const node of handoff.lineage_nodes)
+        if (!lineageRefs.has(node.key))
+            invalidDesignResourceHandoff("lineage_node_unreferenced", node.key);
+    for (const oracle of handoff.oracles)
+        if (!oracleRefs.has(oracle.key))
+            invalidDesignResourceHandoff("oracle_unreferenced", oracle.key);
+    for (const environment of handoff.environments)
+        if (!environmentRefs.has(environment.key))
+            invalidDesignResourceHandoff("environment_unreferenced", environment.key);
 }
 function assertSameSet(actual, expected, code, detail) {
     const left = [...new Set(actual)].sort();

package/dist/lib/design-resource-handoff-validation-fact-cells.d.ts

@@ -0,0 +1,2 @@
+import type { DesignResourceHandoffV1 } from "./design-resource-handoff-types.js";
+export declare function validateDesignResourceFactCells(handoff: DesignResourceHandoffV1, conditions: Map<string, DesignResourceHandoffV1["conditions"][number]>, subjects: Map<string, DesignResourceHandoffV1["subjects"][number]>, targets: Map<string, DesignResourceHandoffV1["targets"][number]>, sourceItems: Map<string, string>): void;

package/dist/lib/design-resource-handoff-validation-fact-cells.js

@@ -0,0 +1,60 @@
+import { invalidDesignResourceHandoff, requireDesignSourceItemKind, requireKnownDesignResourceRef, requireNonemptyDesignResourceValues, requireUniqueDesignResourceValues, } from "./design-resource-handoff-validation-primitives.js";
+export function validateDesignResourceFactCells(handoff, conditions, subjects, targets, sourceItems) {
+    const variations = new Map(handoff.variations.map((item) => [item.key, item]));
+    const properties = new Map(handoff.properties.map((item) => [item.key, item]));
+    const facts = new Map(handoff.facts.map((item) => [item.key, item]));
+    const fingerprints = [];
+    for (const cell of handoff.fact_cells) {
+        validateFactCellReferences(cell, conditions, subjects, targets, variations, properties);
+        validateFactCellBasis(cell, sourceItems);
+        validateFactCellDisposition(cell, facts);
+        fingerprints.push(factCellFingerprint(cell));
+    }
+    requireUniqueDesignResourceValues(fingerprints, "fact_cell_identity_duplicate");
+}
+function validateFactCellReferences(cell, conditions, subjects, targets, variations, properties) {
+    requireKnownDesignResourceRef(subjects, cell.subject_ref, "cell_subject");
+    requireKnownDesignResourceRef(targets, cell.target_ref, "cell_target");
+    requireKnownDesignResourceRef(conditions, cell.condition_ref, "cell_condition");
+    requireKnownDesignResourceRef(variations, cell.variation_ref, "cell_variation");
+    requireKnownDesignResourceRef(properties, cell.property_ref, "cell_property");
+    const subject = subjects.get(cell.subject_ref);
+    const target = targets.get(cell.target_ref);
+    const variation = variations.get(cell.variation_ref);
+    if (!subject.target_refs.includes(cell.target_ref))
+        invalidDesignResourceHandoff("fact_cell_target_outside_subject", cell.key);
+    if (!target.condition_refs.includes(cell.condition_ref))
+        invalidDesignResourceHandoff("fact_cell_condition_outside_target", cell.key);
+    if (variation.subject_ref !== cell.subject_ref)
+        invalidDesignResourceHandoff("fact_cell_variation_subject_mismatch", cell.key);
+}
+function validateFactCellBasis(cell, sourceItems) {
+    requireNonemptyDesignResourceValues(cell.source_item_refs, `fact_cell_source_item_refs_required:${cell.key}`);
+    requireNonemptyDesignResourceValues(cell.basis_refs, `fact_cell_basis_refs_required:${cell.key}`);
+    for (const sourceItemRef of cell.source_item_refs) {
+        requireKnownDesignResourceRef(sourceItems, sourceItemRef, "source_item");
+        requireDesignSourceItemKind(sourceItems, sourceItemRef);
+    }
+}
+function validateFactCellDisposition(cell, facts) {
+    if (cell.disposition === "covered") {
+        if (cell.fact_ref === null)
+            invalidDesignResourceHandoff("covered_fact_cell_fact_required", cell.key);
+        requireKnownDesignResourceRef(facts, cell.fact_ref, "cell_fact");
+        return;
+    }
+    if (cell.fact_ref !== null)
+        invalidDesignResourceHandoff("noncovered_fact_cell_fact_forbidden", cell.key);
+    if (cell.disposition === "decision_required" ||
+        cell.disposition === "unavailable")
+        invalidDesignResourceHandoff("unresolved_fact_cell", cell.key);
+}
+function factCellFingerprint(cell) {
+    return [
+        cell.subject_ref,
+        cell.target_ref,
+        cell.condition_ref,
+        cell.variation_ref,
+        cell.property_ref,
+    ].join("\0");
+}

package/dist/lib/design-resource-handoff-validation-fact-records.d.ts

@@ -0,0 +1,2 @@
+import type { DesignResourceHandoffV1 } from "./design-resource-handoff-types.js";
+export declare function validateDesignResourceFactRecords(handoff: DesignResourceHandoffV1, resources: Map<string, DesignResourceHandoffV1["resources"][number]>, conditions: Map<string, DesignResourceHandoffV1["conditions"][number]>, subjects: Map<string, DesignResourceHandoffV1["subjects"][number]>, targets: Map<string, DesignResourceHandoffV1["targets"][number]>, evidence: Map<string, DesignResourceHandoffV1["evidence"][number]>, sourceItems: Map<string, string>): void;

package/dist/lib/design-resource-handoff-validation-fact-records.js

@@ -0,0 +1,90 @@
+import { designFactEvidenceIsCompatible } from "./design-resource-fact-policy.js";
+import { invalidDesignResourceHandoff, requireDesignSourceItemKind, requireKnownDesignResourceRef, requireNonemptyDesignResourceValues, requireUniqueDesignResourceValues, } from "./design-resource-handoff-validation-primitives.js";
+export function validateDesignResourceFactRecords(handoff, resources, conditions, subjects, targets, evidence, sourceItems) {
+    const variations = new Map(handoff.variations.map((item) => [item.key, item]));
+    const properties = new Map(handoff.properties.map((item) => [item.key, item]));
+    const factCells = new Map(handoff.fact_cells.map((item) => [item.key, item]));
+    const lineageNodes = new Map(handoff.lineage_nodes.map((item) => [item.key, item]));
+    for (const fact of handoff.facts) {
+        validateFactReferences(fact, handoff.scope.surface_keys, conditions, subjects, targets, variations, properties, factCells);
+        validateFactSources(fact, sourceItems);
+        validateFactEvidence(fact, targets.get(fact.target_ref), evidence, resources);
+        validateFactResources(fact, targets.get(fact.target_ref), resources, lineageNodes);
+    }
+}
+function validateFactReferences(fact, scopedSurfaceKeys, conditions, subjects, targets, variations, properties, factCells) {
+    requireKnownDesignResourceRef(subjects, fact.subject_ref, "subject");
+    requireKnownDesignResourceRef(targets, fact.target_ref, "target");
+    requireKnownDesignResourceRef(conditions, fact.condition_ref, "condition");
+    requireKnownDesignResourceRef(variations, fact.variation_ref, "variation");
+    requireKnownDesignResourceRef(properties, fact.property_ref, "property");
+    requireKnownDesignResourceRef(factCells, fact.cell_ref, "fact_cell");
+    const subject = subjects.get(fact.subject_ref);
+    const target = targets.get(fact.target_ref);
+    const variation = variations.get(fact.variation_ref);
+    const property = properties.get(fact.property_ref);
+    const cell = factCells.get(fact.cell_ref);
+    if (!subject.target_refs.includes(fact.target_ref))
+        invalidDesignResourceHandoff("fact_target_outside_subject", `${fact.key}:${fact.subject_ref}:${fact.target_ref}`);
+    if (!target.condition_refs.includes(fact.condition_ref))
+        invalidDesignResourceHandoff("fact_condition_outside_target", `${fact.key}:${fact.target_ref}:${fact.condition_ref}`);
+    if (variation.subject_ref !== fact.subject_ref)
+        invalidDesignResourceHandoff("fact_variation_subject_mismatch", `${fact.key}:${fact.variation_ref}:${fact.subject_ref}`);
+    if (property.dimension !== fact.dimension ||
+        property.value_kind !== fact.value_kind)
+        invalidDesignResourceHandoff("fact_property_definition_mismatch", `${fact.key}:${fact.property_ref}`);
+    if (cell.fact_ref !== fact.key ||
+        cell.disposition !== "covered" ||
+        cell.subject_ref !== fact.subject_ref ||
+        cell.target_ref !== fact.target_ref ||
+        cell.condition_ref !== fact.condition_ref ||
+        cell.variation_ref !== fact.variation_ref ||
+        cell.property_ref !== fact.property_ref)
+        invalidDesignResourceHandoff("fact_cell_mismatch", fact.key);
+    if (fact.observation_scope === "full_target" &&
+        (subject.kind !== "surface" ||
+            !subject.stable_keys.some((key) => scopedSurfaceKeys.includes(key))))
+        invalidDesignResourceHandoff("full_target_fact_surface_required", `${fact.key}:${fact.subject_ref}`);
+}
+function validateFactSources(fact, sourceItems) {
+    requireNonemptyDesignResourceValues(fact.evidence_refs, `fact_evidence_refs_required:${fact.key}`);
+    requireNonemptyDesignResourceValues(fact.source_item_refs, `fact_source_item_refs_required:${fact.key}`);
+    requireUniqueDesignResourceValues(fact.evidence_refs, `fact_evidence_ref_duplicate:${fact.key}`);
+    requireUniqueDesignResourceValues(fact.source_item_refs, `fact_source_item_ref_duplicate:${fact.key}`);
+    for (const sourceItemRef of fact.source_item_refs) {
+        requireKnownDesignResourceRef(sourceItems, sourceItemRef, "source_item");
+        requireDesignSourceItemKind(sourceItems, sourceItemRef);
+    }
+}
+function validateFactEvidence(fact, target, evidence, resources) {
+    let exactResourceEvidence = false;
+    for (const evidenceRef of fact.evidence_refs) {
+        requireKnownDesignResourceRef(evidence, evidenceRef, "evidence");
+        const item = evidence.get(evidenceRef);
+        if (!target.resource_refs.includes(item.resource_ref))
+            invalidDesignResourceHandoff("fact_evidence_outside_target", `${fact.key}:${evidenceRef}:${fact.target_ref}`);
+        if (!item.condition_refs.includes(fact.condition_ref))
+            invalidDesignResourceHandoff("fact_evidence_condition_mismatch", `${fact.key}:${evidenceRef}:${fact.condition_ref}`);
+        if (!designFactEvidenceIsCompatible(fact.dimension, item.kind))
+            invalidDesignResourceHandoff("fact_evidence_kind_incompatible", `${fact.key}:${fact.dimension}:${evidenceRef}:${item.kind}`);
+        if (resources.get(item.resource_ref)?.role === "exact_target")
+            exactResourceEvidence = true;
+    }
+    if (fact.observation_scope === "full_target" && !exactResourceEvidence)
+        invalidDesignResourceHandoff("full_target_fact_exact_resource_required", fact.key);
+}
+function validateFactResources(fact, target, resources, lineageNodes) {
+    for (const resourceRef of [
+        fact.value.locator.resource_ref,
+        fact.lineage.resolved_value.locator.resource_ref,
+    ]) {
+        requireKnownDesignResourceRef(resources, resourceRef, "fact_resource");
+        if (!target.resource_refs.includes(resourceRef))
+            invalidDesignResourceHandoff("fact_value_outside_target", `${fact.key}:${resourceRef}`);
+    }
+    for (const ref of [
+        ...fact.lineage.token_chain_refs,
+        ...fact.lineage.override_chain_refs,
+    ])
+        requireKnownDesignResourceRef(lineageNodes, ref, "fact_lineage_node");
+}

package/dist/lib/design-resource-handoff-validation-facts.js

@@ -1,97 +1,13 @@
-import { assertDesignResourceFactPolicyEnabled, designFactEvidenceIsCompatible, designFactMethodIsCompatible, EXACT_TARGET_FULL_TARGET_METHODS, } from "./design-resource-fact-policy.js";
-import { invalidDesignResourceHandoff, requireDesignSourceItemKind, requireKnownDesignResourceRef, requireNonemptyDesignResourceValues, requireUniqueDesignResourceValues, } from "./design-resource-handoff-validation-primitives.js";
+import { assertDesignResourceFactPolicyEnabled } from "./design-resource-fact-policy.js";
+import { validateDesignResourceFactCells } from "./design-resource-handoff-validation-fact-cells.js";
+import { validateDesignResourceFactRecords } from "./design-resource-handoff-validation-fact-records.js";
+import { validateDesignResourceProofObligations } from "./design-resource-handoff-validation-proofs.js";
+import { validateDesignResourceExactTargetFacts, validateDesignResourceResourceFactClosure, } from "./design-resource-handoff-validation-resource-closure.js";
 export function validateDesignResourceFacts(handoff, resources, conditions, subjects, targets, evidence, sourceItems) {
     assertDesignResourceFactPolicyEnabled();
-    for (const fact of handoff.facts) {
-        requireNonemptyDesignResourceValues(fact.evidence_refs, `fact_evidence_refs_required:${fact.key}`);
-        requireNonemptyDesignResourceValues(fact.source_item_refs, `fact_source_item_refs_required:${fact.key}`);
-        requireUniqueDesignResourceValues(fact.evidence_refs, `fact_evidence_ref_duplicate:${fact.key}`);
-        requireUniqueDesignResourceValues(fact.source_item_refs, `fact_source_item_ref_duplicate:${fact.key}`);
-        requireKnownDesignResourceRef(subjects, fact.subject_ref, "subject");
-        requireKnownDesignResourceRef(targets, fact.target_ref, "target");
-        requireKnownDesignResourceRef(conditions, fact.condition_ref, "condition");
-        const subject = subjects.get(fact.subject_ref);
-        const target = targets.get(fact.target_ref);
-        if (!subject.target_refs.includes(fact.target_ref))
-            invalidDesignResourceHandoff("fact_target_outside_subject", `${fact.key}:${fact.subject_ref}:${fact.target_ref}`);
-        if (!target.condition_refs.includes(fact.condition_ref))
-            invalidDesignResourceHandoff("fact_condition_outside_target", `${fact.key}:${fact.target_ref}:${fact.condition_ref}`);
-        if (fact.observation_scope === "full_target" &&
-            (subject.kind !== "surface" ||
-                !subject.stable_keys.some((key) => handoff.scope.surface_keys.includes(key))))
-            invalidDesignResourceHandoff("full_target_fact_surface_required", `${fact.key}:${fact.subject_ref}`);
-        if (!designFactMethodIsCompatible(fact.dimension, fact.verification_method))
-            invalidDesignResourceHandoff("fact_verification_method_incompatible", `${fact.key}:${fact.dimension}:${fact.verification_method}`);
-        for (const sourceItemRef of fact.source_item_refs) {
-            requireKnownDesignResourceRef(sourceItems, sourceItemRef, "source_item");
-            requireDesignSourceItemKind(sourceItems, sourceItemRef);
-        }
-        let exactResourceEvidence = false;
-        for (const evidenceRef of fact.evidence_refs) {
-            requireKnownDesignResourceRef(evidence, evidenceRef, "evidence");
-            const item = evidence.get(evidenceRef);
-            if (!target.resource_refs.includes(item.resource_ref))
-                invalidDesignResourceHandoff("fact_evidence_outside_target", `${fact.key}:${evidenceRef}:${fact.target_ref}`);
-            if (!item.condition_refs.includes(fact.condition_ref))
-                invalidDesignResourceHandoff("fact_evidence_condition_mismatch", `${fact.key}:${evidenceRef}:${fact.condition_ref}`);
-            if (!designFactEvidenceIsCompatible(fact.dimension, item.kind))
-                invalidDesignResourceHandoff("fact_evidence_kind_incompatible", `${fact.key}:${fact.dimension}:${evidenceRef}:${item.kind}`);
-            if (resources.get(item.resource_ref)?.role === "exact_target")
-                exactResourceEvidence = true;
-        }
-        if (fact.observation_scope === "full_target" && !exactResourceEvidence)
-            invalidDesignResourceHandoff("full_target_fact_exact_resource_required", fact.key);
-    }
-    validateExactTargetFacts(handoff);
-    validateResourceFactClosure(handoff, resources, evidence);
-}
-function validateExactTargetFacts(handoff) {
-    for (const target of handoff.targets) {
-        if (target.interpretation !== "exact_target")
-            continue;
-        for (const conditionRef of target.condition_refs)
-            for (const method of EXACT_TARGET_FULL_TARGET_METHODS)
-                if (!handoff.facts.some((fact) => fact.target_ref === target.key &&
-                    fact.condition_ref === conditionRef &&
-                    fact.observation_scope === "full_target" &&
-                    fact.verification_method === method))
-                    invalidDesignResourceHandoff("exact_target_full_target_fact_missing", `${target.key}:${conditionRef}:${method}`);
-    }
-}
-function validateResourceFactClosure(handoff, resources, evidence) {
-    const closuresByResource = new Map();
-    for (const closure of handoff.resource_fact_closure) {
-        requireKnownDesignResourceRef(resources, closure.resource_ref, "resource_fact_closure_resource");
-        if (closuresByResource.has(closure.resource_ref))
-            invalidDesignResourceHandoff("resource_fact_closure_duplicate", closure.resource_ref);
-        closuresByResource.set(closure.resource_ref, closure.key);
-        requireUniqueDesignResourceValues(closure.fact_refs, `resource_fact_closure_fact_ref_duplicate:${closure.key}`);
-        const expected = handoff.facts
-            .filter((fact) => fact.evidence_refs.some((evidenceRef) => evidence.get(evidenceRef)?.resource_ref === closure.resource_ref))
-            .map((fact) => fact.key);
-        for (const factRef of closure.fact_refs)
-            if (!handoff.facts.some((fact) => fact.key === factRef))
-                invalidDesignResourceHandoff("resource_fact_closure_fact_unknown", `${closure.key}:${factRef}`);
-        assertSameSet(closure.fact_refs, expected, "resource_fact_closure_mismatch", closure.resource_ref);
-        const resource = resources.get(closure.resource_ref);
-        if (closure.disposition === "material_with_facts" &&
-            closure.fact_refs.length === 0)
-            invalidDesignResourceHandoff("resource_fact_closure_facts_required", closure.key);
-        if (closure.disposition === "supporting_only" &&
-            closure.fact_refs.length > 0)
-            invalidDesignResourceHandoff("supporting_only_resource_fact_forbidden", closure.key);
-        if (resource.role !== "supporting" &&
-            closure.disposition !== "material_with_facts")
-            invalidDesignResourceHandoff("target_resource_fact_closure_required", `${closure.key}:${resource.role}`);
-    }
-    for (const resource of handoff.resources)
-        if (!closuresByResource.has(resource.key))
-            invalidDesignResourceHandoff("resource_fact_closure_missing", resource.key);
-}
-function assertSameSet(actual, expected, code, detail) {
-    const left = [...new Set(actual)].sort();
-    const right = [...new Set(expected)].sort();
-    if (left.length !== right.length ||
-        left.some((item, index) => item !== right[index]))
-        invalidDesignResourceHandoff(code, `${detail}:${left.join(",")}:${right.join(",")}`);
+    validateDesignResourceFactCells(handoff, conditions, subjects, targets, sourceItems);
+    validateDesignResourceFactRecords(handoff, resources, conditions, subjects, targets, evidence, sourceItems);
+    validateDesignResourceProofObligations(handoff, resources, targets, evidence);
+    validateDesignResourceExactTargetFacts(handoff);
+    validateDesignResourceResourceFactClosure(handoff, resources, evidence);
 }

package/dist/lib/design-resource-handoff-validation-proofs.d.ts

@@ -0,0 +1,2 @@
+import type { DesignResourceHandoffV1 } from "./design-resource-handoff-types.js";
+export declare function validateDesignResourceProofObligations(handoff: DesignResourceHandoffV1, resources: Map<string, DesignResourceHandoffV1["resources"][number]>, targets: Map<string, DesignResourceHandoffV1["targets"][number]>, evidence: Map<string, DesignResourceHandoffV1["evidence"][number]>): void;