project-tiny-context-harness 0.11.0 → 0.12.0

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

@@ -1,223 +0,0 @@
-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 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 referencedProofs = new Set();
-    for (const row of handoff.coverage) {
-        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);
-        }
-        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, cells, evidence, facts, proofs, referencedFacts, referencedProofs);
-        else
-            validateNoncoveredRow(row, cells);
-    }
-    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 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 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],
-        ]) {
-            requireNonemptyDesignResourceValues(values, `acceptance_blocker_${name}_required:${blocker.key}`);
-            requireUniqueDesignResourceValues(values, `acceptance_blocker_${name}_duplicate:${blocker.key}`);
-        }
-        for (const ref of blocker.target_refs)
-            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);
-        }
-        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}`);
-        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);
-    for (const condition of handoff.conditions)
-        if (!targetConditions.has(condition.key))
-            invalidDesignResourceHandoff("condition_unreferenced", condition.key);
-    for (const target of handoff.targets)
-        if (!coverageTargets.has(target.key))
-            invalidDesignResourceHandoff("target_without_covered_dimension", target.key);
-    for (const item of handoff.evidence)
-        if (!coverageEvidence.has(item.key))
-            invalidDesignResourceHandoff("evidence_unreferenced", item.key);
-    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();
-    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(",")}`);
-}

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

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

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

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

@@ -1,90 +0,0 @@
-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.d.ts

@@ -1,2 +0,0 @@
-import type { DesignResourceHandoffV1 } from "./design-resource-handoff-types.js";
-export declare function validateDesignResourceFacts(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-facts.js

@@ -1,13 +0,0 @@
-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();
-    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-primitives.d.ts

@@ -1,11 +0,0 @@
-export declare function indexDesignResourceItems<T extends {
-    key: string;
-}>(items: T[]): Map<string, T>;
-export declare function requireUniqueDesignResourceObjects(items: Array<{
-    key: string;
-}>, code: string): void;
-export declare function requireUniqueDesignResourceValues<T>(values: T[], code: string): void;
-export declare function requireNonemptyDesignResourceValues(values: readonly unknown[], code: string): void;
-export declare function requireKnownDesignResourceRef(known: Map<string, unknown> | Set<string>, ref: string, kind: string): void;
-export declare function requireDesignSourceItemKind(sourceItems: Map<string, string>, ref: string): void;
-export declare function invalidDesignResourceHandoff(code: string, detail: string): never;

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

@@ -1,26 +0,0 @@
-export function indexDesignResourceItems(items) {
-    return new Map(items.map((item) => [item.key, item]));
-}
-export function requireUniqueDesignResourceObjects(items, code) {
-    requireUniqueDesignResourceValues(items.map((item) => item.key), code);
-}
-export function requireUniqueDesignResourceValues(values, code) {
-    if (new Set(values).size !== values.length)
-        invalidDesignResourceHandoff(code, "duplicate");
-}
-export function requireNonemptyDesignResourceValues(values, code) {
-    if (!values.length)
-        invalidDesignResourceHandoff(code, "empty");
-}
-export function requireKnownDesignResourceRef(known, ref, kind) {
-    if (!known.has(ref))
-        invalidDesignResourceHandoff(`${kind}_ref_unknown`, ref);
-}
-export function requireDesignSourceItemKind(sourceItems, ref) {
-    const kind = sourceItems.get(ref);
-    if (!["requirement", "control", "acceptance"].includes(kind))
-        invalidDesignResourceHandoff("design_source_item_kind_unsupported", `${ref}:${kind}`);
-}
-export function invalidDesignResourceHandoff(code, detail) {
-    throw new Error(`design_resource_handoff_invalid:${code}:${detail}`);
-}

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

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

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

@@ -1,67 +0,0 @@
-import { designFactComparatorSupportsMethod, designFactEvidenceSupportsMethod, designFactMethodIsCompatible, designFactOracleSupportsMethod, } from "./design-resource-fact-policy.js";
-import { invalidDesignResourceHandoff, requireKnownDesignResourceRef, requireUniqueDesignResourceValues, } from "./design-resource-handoff-validation-primitives.js";
-export function validateDesignResourceProofObligations(handoff, resources, targets, evidence) {
-    const facts = new Map(handoff.facts.map((item) => [item.key, item]));
-    const oracles = new Map(handoff.oracles.map((item) => [item.key, item]));
-    const environments = new Map(handoff.environments.map((item) => [item.key, item]));
-    const proofByFact = new Map();
-    const factMethodPairs = [];
-    for (const proof of handoff.proof_obligations) {
-        validateProofReferences(proof, facts, oracles, environments);
-        validateProofMethod(proof, facts.get(proof.fact_ref), oracles.get(proof.oracle_ref), evidence);
-        validateProofResources(proof, facts.get(proof.fact_ref), environments, resources, targets);
-        validateProofComparison(proof);
-        proofByFact.set(proof.fact_ref, (proofByFact.get(proof.fact_ref) ?? 0) + 1);
-        factMethodPairs.push(`${proof.fact_ref}\0${proof.method}`);
-    }
-    requireUniqueDesignResourceValues(factMethodPairs, "fact_verification_method_obligation_duplicate");
-    for (const fact of handoff.facts)
-        if (!proofByFact.has(fact.key))
-            invalidDesignResourceHandoff("fact_verification_method_required", fact.key);
-    for (const environment of handoff.environments)
-        requireKnownDesignResourceRef(resources, environment.definition.locator.resource_ref, "environment_resource");
-}
-function validateProofReferences(proof, facts, oracles, environments) {
-    requireKnownDesignResourceRef(facts, proof.fact_ref, "proof_fact");
-    requireKnownDesignResourceRef(oracles, proof.oracle_ref, "proof_oracle");
-    requireKnownDesignResourceRef(environments, proof.environment_ref, "proof_environment");
-}
-function validateProofMethod(proof, fact, oracle, evidence) {
-    if (!designFactMethodIsCompatible(fact.dimension, proof.method))
-        invalidDesignResourceHandoff("proof_verification_method_incompatible", `${proof.key}:${fact.dimension}:${proof.method}`);
-    if (!fact.evidence_refs.some((ref) => designFactEvidenceSupportsMethod(proof.method, evidence.get(ref).kind)))
-        invalidDesignResourceHandoff("proof_method_evidence_missing", `${proof.key}:${proof.fact_ref}:${proof.method}`);
-    if (!designFactComparatorSupportsMethod(proof.method, proof.comparison.comparator))
-        invalidDesignResourceHandoff("proof_comparator_method_incompatible", `${proof.key}:${proof.method}:${proof.comparison.comparator}`);
-    if (!designFactOracleSupportsMethod(proof.method, oracle.capability_refs))
-        invalidDesignResourceHandoff("proof_oracle_capability_missing", `${proof.key}:${proof.oracle_ref}:${proof.method}`);
-}
-function validateProofResources(proof, fact, environments, resources, targets) {
-    const target = targets.get(fact.target_ref);
-    const environmentResourceRef = environments.get(proof.environment_ref)
-        .definition.locator.resource_ref;
-    if (!target.resource_refs.includes(environmentResourceRef))
-        invalidDesignResourceHandoff("proof_environment_outside_target", `${proof.key}:${proof.environment_ref}:${environmentResourceRef}`);
-    for (const located of [
-        proof.comparison.parameters,
-        proof.comparison.tolerance,
-        proof.comparison.mask,
-    ])
-        if (located) {
-            requireKnownDesignResourceRef(resources, located.locator.resource_ref, "proof_resource");
-            if (!target.resource_refs.includes(located.locator.resource_ref))
-                invalidDesignResourceHandoff("proof_resource_outside_target", `${proof.key}:${located.locator.resource_ref}`);
-        }
-}
-function validateProofComparison(proof) {
-    if (proof.comparison.mode === "exact" &&
-        (proof.comparison.tolerance !== null || proof.comparison.mask !== null))
-        invalidDesignResourceHandoff("proof_exact_tolerance_forbidden", proof.key);
-    if (proof.comparison.mode === "tolerance" &&
-        proof.comparison.tolerance === null)
-        invalidDesignResourceHandoff("proof_tolerance_required", proof.key);
-    if (proof.comparison.mask !== null &&
-        proof.comparison.comparator !== "pixel_diff" &&
-        !proof.comparison.comparator.startsWith("custom."))
-        invalidDesignResourceHandoff("proof_mask_comparator_incompatible", `${proof.key}:${proof.comparison.comparator}`);
-}

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

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

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

@@ -1,88 +0,0 @@
-import { EXACT_TARGET_FULL_TARGET_METHODS } from "./design-resource-fact-policy.js";
-import { invalidDesignResourceHandoff, requireKnownDesignResourceRef, requireUniqueDesignResourceValues, } from "./design-resource-handoff-validation-primitives.js";
-export function validateDesignResourceExactTargetFacts(handoff) {
-    const proofsByFact = new Map();
-    for (const proof of handoff.proof_obligations) {
-        const methods = proofsByFact.get(proof.fact_ref) ?? [];
-        methods.push(proof.method);
-        proofsByFact.set(proof.fact_ref, methods);
-    }
-    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 (!hasExactTargetFact(handoff, target.key, conditionRef, method, proofsByFact))
-                    invalidDesignResourceHandoff("exact_target_full_target_fact_missing", `${target.key}:${conditionRef}:${method}`);
-    }
-}
-function hasExactTargetFact(handoff, targetRef, conditionRef, method, proofsByFact) {
-    return handoff.facts.some((fact) => fact.target_ref === targetRef &&
-        fact.condition_ref === conditionRef &&
-        fact.observation_scope === "full_target" &&
-        (proofsByFact.get(fact.key) ?? []).includes(method));
-}
-export function validateDesignResourceResourceFactClosure(handoff, resources, evidence) {
-    const lineageNodes = new Map(handoff.lineage_nodes.map((item) => [item.key, item]));
-    const proofsByFact = new Map(handoff.facts.map((fact) => [
-        fact.key,
-        handoff.proof_obligations.filter((proof) => proof.fact_ref === fact.key),
-    ]));
-    const environments = new Map(handoff.environments.map((environment) => [environment.key, environment]));
-    const closuresByResource = new Map();
-    for (const closure of handoff.resource_fact_closure) {
-        validateResourceClosure(closure, handoff, resources, evidence, lineageNodes, proofsByFact, environments);
-        if (closuresByResource.has(closure.resource_ref))
-            invalidDesignResourceHandoff("resource_fact_closure_duplicate", closure.resource_ref);
-        closuresByResource.set(closure.resource_ref, closure.key);
-    }
-    for (const resource of handoff.resources)
-        if (!closuresByResource.has(resource.key))
-            invalidDesignResourceHandoff("resource_fact_closure_missing", resource.key);
-}
-function validateResourceClosure(closure, handoff, resources, evidence, lineageNodes, proofsByFact, environments) {
-    requireKnownDesignResourceRef(resources, closure.resource_ref, "resource_fact_closure_resource");
-    requireUniqueDesignResourceValues(closure.fact_refs, `resource_fact_closure_fact_ref_duplicate:${closure.key}`);
-    const expected = handoff.facts
-        .filter((fact) => factUsesResource(fact, closure.resource_ref, proofsByFact.get(fact.key) ?? [], environments, lineageNodes, evidence))
-        .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);
-    validateClosureDisposition(closure, resources.get(closure.resource_ref));
-}
-function factUsesResource(fact, resourceRef, proofs, environments, lineageNodes, evidence) {
-    const proofResources = proofs.flatMap((proof) => [
-        proof.comparison.parameters.locator.resource_ref,
-        proof.comparison.tolerance?.locator.resource_ref,
-        proof.comparison.mask?.locator.resource_ref,
-        environments.get(proof.environment_ref)?.definition.locator.resource_ref,
-    ]);
-    const lineageResources = [
-        ...fact.lineage.token_chain_refs,
-        ...fact.lineage.override_chain_refs,
-    ].map((ref) => lineageNodes.get(ref)?.value.locator.resource_ref);
-    return (fact.value.locator.resource_ref === resourceRef ||
-        fact.lineage.resolved_value.locator.resource_ref === resourceRef ||
-        lineageResources.includes(resourceRef) ||
-        proofResources.includes(resourceRef) ||
-        fact.evidence_refs.some((evidenceRef) => evidence.get(evidenceRef)?.resource_ref === resourceRef));
-}
-function validateClosureDisposition(closure, resource) {
-    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}`);
-}
-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(",")}`);
-}

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

@@ -1,6 +0,0 @@
-import type { DesignResourceHandoffV1 } from "./design-resource-handoff-types.js";
-export declare function validateDesignResourceScope(handoff: DesignResourceHandoffV1): void;
-export declare function validateDesignResourceConditions(handoff: DesignResourceHandoffV1): void;
-export declare function validateDesignResourceSubjects(handoff: DesignResourceHandoffV1, targets: Map<string, DesignResourceHandoffV1["targets"][number]>): void;
-export declare function validateDesignResourceTargets(handoff: DesignResourceHandoffV1, resources: Map<string, DesignResourceHandoffV1["resources"][number]>, conditions: Map<string, DesignResourceHandoffV1["conditions"][number]>): void;
-export declare function validateDesignResourceEvidence(handoff: DesignResourceHandoffV1, resources: Map<string, unknown>, conditions: Map<string, unknown>): void;