project-tiny-context-harness 0.8.4 → 0.8.6

package/dist/lib/design-resource-fact-universe-inspector.js

@@ -0,0 +1,119 @@
+import { resolveDesignResourceLocatorValue, validateDesignResourceLocatedDigest, } from "./design-resource-fact-locator-validation.js";
+import { invalid, nonempty, refsKnown, sameSet, unique, validateBasis, } from "./design-resource-fact-universe-helpers.js";
+export function validateManifestLineageNodes(manifest, census, resources, contents) {
+    const nodes = new Map(manifest.lineage_nodes.map((node) => [node.key, node]));
+    for (const node of manifest.lineage_nodes) {
+        unique(node.predecessor_refs, `manifest_lineage_predecessor_duplicate:${node.key}`);
+        refsKnown(node.predecessor_refs, nodes, "manifest_lineage_predecessor_unknown", node.key);
+        if (node.predecessor_refs.includes(node.key))
+            invalid("manifest_lineage_self_reference", node.key);
+        if (["base_token", "direct_value"].includes(node.kind) &&
+            node.predecessor_refs.length)
+            invalid("manifest_lineage_root_predecessor_forbidden", node.key);
+        if (!["base_token", "direct_value"].includes(node.kind) &&
+            node.predecessor_refs.length === 0)
+            invalid("manifest_lineage_predecessor_required", node.key);
+        nonempty(node.census_refs, `manifest_lineage_census_required:${node.key}`);
+        refsKnown(node.census_refs, census, "manifest_lineage_census_unknown", node.key);
+        for (const ref of node.census_refs)
+            if (!["token", "declaration"].includes(census.get(ref).kind))
+                invalid("manifest_lineage_census_kind_invalid", `${node.key}:${ref}:${census.get(ref).kind}`);
+        validateDesignResourceLocatedDigest(node.value, resources, contents, `manifest.lineage_node.${node.key}.value`);
+    }
+    validateLineageAcyclic(manifest, nodes);
+}
+function validateLineageAcyclic(manifest, nodes) {
+    for (const node of manifest.lineage_nodes) {
+        const visiting = new Set();
+        const visited = new Set();
+        const walk = (ref) => {
+            if (visiting.has(ref))
+                invalid("manifest_lineage_cycle", node.key);
+            if (visited.has(ref))
+                return;
+            visiting.add(ref);
+            for (const predecessor of nodes.get(ref).predecessor_refs)
+                walk(predecessor);
+            visiting.delete(ref);
+            visited.add(ref);
+        };
+        walk(node.key);
+    }
+}
+export function validateManifestInspector(manifest, handoff, target, resources, contents, sourceItems) {
+    const inspector = manifest.inspector;
+    validateInspectorIdentity(inspector);
+    if (inspector.entry_resource_ref !== target.source_profile.entry_resource_ref)
+        invalid("manifest_inspector_entry_mismatch", `${manifest.target_key}:${inspector.entry_resource_ref}:${target.source_profile.entry_resource_ref}`);
+    validateInspectorInputs(manifest, target, resources);
+    validateInspectorCensus(manifest, resources, contents, sourceItems);
+    const expectedInspectorIdentity = `${inspector.identity}@${inspector.version}`;
+    for (const resourceRef of target.resource_refs) {
+        const closure = handoff.resource_fact_closure.find((item) => item.resource_ref === resourceRef);
+        if (!closure || closure.inspection.inspector !== expectedInspectorIdentity)
+            invalid("manifest_resource_closure_inspector_mismatch", `${resourceRef}:${closure?.inspection.inspector ?? "missing"}:${expectedInspectorIdentity}`);
+    }
+}
+function validateInspectorIdentity(inspector) {
+    if (inspector.trust === "frozen_executable" &&
+        inspector.implementation_sha256 === null)
+        invalid("manifest_inspector_digest_required", inspector.identity);
+    if (inspector.trust === "named_external_tcb" &&
+        inspector.implementation_sha256 !== null)
+        invalid("manifest_external_inspector_digest_forbidden", inspector.identity);
+    nonempty(inspector.capability_refs, "manifest_inspector_capabilities_required");
+    unique(inspector.capability_refs, "manifest_inspector_capability_duplicate");
+}
+function validateInspectorInputs(manifest, target, resources) {
+    const manifestResourceRef = target.source_profile.fact_manifest_resource_ref;
+    const expectedInputs = target.resource_refs
+        .filter((ref) => ref !== manifestResourceRef)
+        .map((ref) => {
+        const resource = resources.get(ref);
+        return `${ref}\0${resource.path}\0${resource.sha256}`;
+    });
+    const actualInputs = manifest.inspector.input_resources.map((item) => `${item.resource_ref}\0${item.path}\0${item.sha256}`);
+    sameSet(actualInputs, expectedInputs, "manifest_inspector_input_resource_mismatch", manifest.target_key);
+    unique(manifest.inspector.input_resources.map((item) => item.resource_ref), "manifest_inspector_input_resource_duplicate");
+}
+function validateInspectorCensus(manifest, resources, contents, sourceItems) {
+    const inputRefs = new Set(manifest.inspector.input_resources.map((item) => item.resource_ref));
+    const censusByResource = new Map();
+    const censusFactRefs = new Set();
+    const censusFactCellRefs = new Set();
+    const facts = new Map(manifest.facts.map((fact) => [fact.key, fact]));
+    const factCells = new Map(manifest.fact_cells.map((cell) => [cell.key, cell]));
+    const censusEntries = new Map(manifest.inspector.census.map((entry) => [entry.key, entry]));
+    for (const entry of manifest.inspector.census) {
+        validateCensusEntry(entry, inputRefs, censusByResource, facts, factCells, censusEntries, resources, contents, sourceItems);
+        for (const ref of entry.fact_refs)
+            censusFactRefs.add(ref);
+        for (const ref of entry.fact_cell_refs)
+            censusFactCellRefs.add(ref);
+    }
+    for (const ref of inputRefs)
+        if (!censusByResource.has(ref))
+            invalid("manifest_census_resource_missing", ref);
+    sameSet([...censusFactRefs], manifest.facts.map((fact) => fact.key), "manifest_census_fact_set_mismatch", manifest.target_key);
+    sameSet([...censusFactCellRefs], manifest.fact_cells.map((cell) => cell.key), "manifest_census_fact_cell_set_mismatch", manifest.target_key);
+}
+function validateCensusEntry(entry, inputRefs, censusByResource, facts, factCells, censusEntries, resources, contents, sourceItems) {
+    validateBasis(entry, sourceItems, censusEntries, `manifest_census:${entry.key}`);
+    if (entry.basis_refs.includes(entry.key))
+        invalid("manifest_census_self_basis_forbidden", entry.key);
+    if (!inputRefs.has(entry.resource_ref))
+        invalid("manifest_census_resource_outside_inputs", `${entry.key}:${entry.resource_ref}`);
+    censusByResource.set(entry.resource_ref, (censusByResource.get(entry.resource_ref) ?? 0) + 1);
+    resolveDesignResourceLocatorValue({ resource_ref: entry.resource_ref, ...entry.locator }, resources.get(entry.resource_ref), contents.get(entry.resource_ref), `manifest.census.${entry.key}`);
+    unique(entry.fact_refs, `manifest_census_fact_ref_duplicate:${entry.key}`);
+    unique(entry.fact_cell_refs, `manifest_census_fact_cell_ref_duplicate:${entry.key}`);
+    refsKnown(entry.fact_refs, facts, "manifest_census_fact_ref_unknown", entry.key);
+    refsKnown(entry.fact_cell_refs, factCells, "manifest_census_fact_cell_ref_unknown", entry.key);
+    if (entry.disposition === "covered" &&
+        entry.fact_refs.length === 0 &&
+        entry.fact_cell_refs.length === 0)
+        invalid("manifest_census_covered_binding_required", entry.key);
+    if (entry.disposition === "non_material" &&
+        (entry.fact_refs.length > 0 || entry.fact_cell_refs.length > 0))
+        invalid("manifest_census_non_material_binding_forbidden", entry.key);
+}

package/dist/lib/design-resource-fact-universe-proof.d.ts

@@ -0,0 +1,4 @@
+import type { DesignResourceObservableFactManifestV1 } from "./design-resource-fact-manifest-types.js";
+import type { DesignResource } from "./design-resource-handoff-file-primitives.js";
+import type { DesignResourceHandoffTargetV1 } from "./design-resource-handoff-types.js";
+export declare function validateManifestProofAndEvidence(manifest: DesignResourceObservableFactManifestV1, target: DesignResourceHandoffTargetV1, resources: Map<string, DesignResource>, contents: Map<string, Buffer>): void;

package/dist/lib/design-resource-fact-universe-proof.js

@@ -0,0 +1,113 @@
+import { designFactComparatorSupportsMethod, designFactMethodIsCompatible, designFactOracleSupportsMethod, EXACT_TARGET_FULL_TARGET_METHODS, } from "./design-resource-fact-policy.js";
+import { resolveDesignResourceLocatorValue, validateDesignResourceLocatedDigest, } from "./design-resource-fact-locator-validation.js";
+import { invalid, nonempty, unique, } from "./design-resource-fact-universe-helpers.js";
+export function validateManifestProofAndEvidence(manifest, target, resources, contents) {
+    validateOraclesAndEnvironments(manifest, resources, contents);
+    validateProofObligations(manifest, resources, contents);
+    validateExactTargetFullTargetProof(manifest, target);
+    validateEvidence(manifest, resources, contents);
+}
+function validateOraclesAndEnvironments(manifest, resources, contents) {
+    for (const oracle of manifest.oracles) {
+        nonempty(oracle.capability_refs, `manifest_oracle_capabilities_required:${oracle.key}`);
+        unique(oracle.capability_refs, `manifest_oracle_capability_duplicate:${oracle.key}`);
+        if (oracle.trust === "frozen_executable" && oracle.sha256 === null)
+            invalid("manifest_oracle_digest_required", oracle.key);
+        if (oracle.trust === "named_external_tcb" && oracle.sha256 !== null)
+            invalid("manifest_external_oracle_digest_forbidden", oracle.key);
+    }
+    for (const environment of manifest.environments)
+        validateDesignResourceLocatedDigest(environment.definition, resources, contents, `manifest.environment.${environment.key}`);
+}
+function validateProofObligations(manifest, resources, contents) {
+    const properties = new Map(manifest.properties.map((property) => [property.key, property]));
+    const oracles = new Map(manifest.oracles.map((item) => [item.key, item]));
+    const environments = new Map(manifest.environments.map((item) => [item.key, item]));
+    const proofMethodsByFact = new Map();
+    const factMethodIdentities = [];
+    for (const proof of manifest.proof_obligations) {
+        validateProof(proof, manifest, oracles, environments, resources, contents);
+        const identity = `${proof.fact_ref}\0${proof.method}`;
+        factMethodIdentities.push(identity);
+        const methods = proofMethodsByFact.get(proof.fact_ref) ?? new Set();
+        methods.add(proof.method);
+        proofMethodsByFact.set(proof.fact_ref, methods);
+    }
+    unique(factMethodIdentities, "manifest_fact_method_obligation_duplicate");
+    for (const fact of manifest.facts) {
+        const actualMethods = proofMethodsByFact.get(fact.key);
+        if (!actualMethods)
+            invalid("manifest_fact_proof_obligation_required", fact.key);
+        const requiredMethods = new Set(properties.get(fact.property_ref).required_methods);
+        if (fact.lineage.design_system_ref !== null &&
+            (fact.lineage.token_chain_refs.length > 0 ||
+                fact.lineage.override_chain_refs.length > 0))
+            requiredMethods.add("design_token");
+        for (const method of requiredMethods)
+            if (!actualMethods.has(method))
+                invalid("manifest_fact_required_proof_method_missing", `${fact.key}:${method}`);
+    }
+}
+function validateProof(proof, manifest, oracles, environments, resources, contents) {
+    const fact = manifest.facts.find((item) => item.key === proof.fact_ref);
+    if (!fact)
+        invalid("manifest_proof_fact_unknown", proof.key);
+    if (!designFactMethodIsCompatible(fact.dimension, proof.method))
+        invalid("manifest_proof_method_incompatible", `${proof.key}:${fact.dimension}:${proof.method}`);
+    if (!designFactComparatorSupportsMethod(proof.method, proof.comparison.comparator))
+        invalid("manifest_proof_comparator_method_incompatible", `${proof.key}:${proof.method}:${proof.comparison.comparator}`);
+    const oracle = oracles.get(proof.oracle_ref);
+    if (!oracle)
+        invalid("manifest_proof_oracle_unknown", proof.key);
+    if (!designFactOracleSupportsMethod(proof.method, oracle.capability_refs))
+        invalid("manifest_proof_oracle_capability_missing", `${proof.key}:${proof.oracle_ref}:${proof.method}`);
+    if (!environments.has(proof.environment_ref))
+        invalid("manifest_proof_environment_unknown", proof.key);
+    validateComparison(proof, resources, contents);
+}
+function validateComparison(proof, resources, contents) {
+    validateDesignResourceLocatedDigest(proof.comparison.parameters, resources, contents, `manifest.proof.${proof.key}.parameters`);
+    if (proof.comparison.mode === "exact") {
+        if (proof.comparison.tolerance !== null || proof.comparison.mask !== null)
+            invalid("manifest_exact_proof_tolerance_forbidden", proof.key);
+    }
+    else if (proof.comparison.tolerance === null)
+        invalid("manifest_tolerance_proof_tolerance_required", proof.key);
+    if (proof.comparison.tolerance)
+        validateDesignResourceLocatedDigest(proof.comparison.tolerance, resources, contents, `manifest.proof.${proof.key}.tolerance`);
+    if (proof.comparison.mask)
+        validateDesignResourceLocatedDigest(proof.comparison.mask, resources, contents, `manifest.proof.${proof.key}.mask`);
+    if (proof.comparison.mask !== null &&
+        proof.comparison.comparator !== "pixel_diff" &&
+        !proof.comparison.comparator.startsWith("custom."))
+        invalid("manifest_proof_mask_comparator_incompatible", `${proof.key}:${proof.comparison.comparator}`);
+}
+function validateExactTargetFullTargetProof(manifest, target) {
+    if (target.interpretation !== "exact_target")
+        return;
+    for (const condition of manifest.conditions)
+        for (const method of EXACT_TARGET_FULL_TARGET_METHODS)
+            if (!hasFullTargetProof(manifest, condition.key, method))
+                invalid("manifest_exact_target_full_target_proof_missing", `${target.key}:${condition.key}:${method}`);
+}
+function hasFullTargetProof(manifest, conditionRef, method) {
+    return manifest.proof_obligations.some((proof) => {
+        const fact = manifest.facts.find((item) => item.key === proof.fact_ref);
+        return (fact?.condition_ref === conditionRef &&
+            fact.observation_scope === "full_target" &&
+            proof.method === method);
+    });
+}
+function validateEvidence(manifest, resources, contents) {
+    const conditions = new Set(manifest.conditions.map((item) => item.key));
+    for (const evidenceItem of manifest.evidence) {
+        const resource = resources.get(evidenceItem.resource_ref);
+        const bytes = contents.get(evidenceItem.resource_ref);
+        if (!resource || !bytes)
+            invalid("manifest_evidence_resource_unknown", evidenceItem.key);
+        for (const conditionRef of evidenceItem.condition_refs)
+            if (!conditions.has(conditionRef))
+                invalid("manifest_evidence_condition_unknown", `${evidenceItem.key}:${conditionRef}`);
+        resolveDesignResourceLocatorValue({ resource_ref: evidenceItem.resource_ref, ...evidenceItem.locator }, resource, bytes, `manifest.evidence.${evidenceItem.key}`);
+    }
+}

package/dist/lib/design-resource-fact-universe-subjects.d.ts

@@ -0,0 +1,5 @@
+import type { DesignResourceObservableFactManifestV1 } from "./design-resource-fact-manifest-types.js";
+import type { DesignResource } from "./design-resource-handoff-file-primitives.js";
+import type { DesignResourceHandoffTargetV1, DesignResourceHandoffV1 } from "./design-resource-handoff-types.js";
+export declare function validateManifestDesignSystem(manifest: DesignResourceObservableFactManifestV1, handoff: DesignResourceHandoffV1, target: DesignResourceHandoffTargetV1, resources: Map<string, DesignResource>): void;
+export declare function validateManifestSubjects(manifest: DesignResourceObservableFactManifestV1, census: Map<string, DesignResourceObservableFactManifestV1["inspector"]["census"][number]>): void;

package/dist/lib/design-resource-fact-universe-subjects.js

@@ -0,0 +1,97 @@
+import { invalid, nonempty, refsKnown, unique, } from "./design-resource-fact-universe-helpers.js";
+export function validateManifestDesignSystem(manifest, handoff, target, resources) {
+    const snapshot = manifest.design_system;
+    const styleBearing = handoff.scope.style_dependency !== "non-fidelity";
+    if (styleBearing && snapshot.disposition !== "used")
+        invalid("manifest_design_system_required", manifest.target_key);
+    if (!styleBearing && snapshot.disposition !== "not_applicable")
+        invalid("manifest_design_system_not_applicable_required", manifest.target_key);
+    if (snapshot.id !== handoff.provenance.design_system_id)
+        invalid("manifest_design_system_id_mismatch", `${snapshot.id}:${handoff.provenance.design_system_id}`);
+    const resource = resources.get(snapshot.resource_ref);
+    if (!resource)
+        invalid("manifest_design_system_resource_unknown", snapshot.resource_ref);
+    if (!target.resource_refs.includes(snapshot.resource_ref))
+        invalid("manifest_design_system_resource_outside_target", `${target.key}:${snapshot.resource_ref}`);
+    if (resource.sha256 !== snapshot.sha256)
+        invalid("manifest_design_system_digest_mismatch", `${snapshot.resource_ref}:${snapshot.sha256}:${resource.sha256}`);
+}
+export function validateManifestSubjects(manifest, census) {
+    const subjects = new Map(manifest.subjects.map((subject) => [subject.key, subject]));
+    const roots = manifest.subjects.filter((subject) => subject.parent_ref === null &&
+        (subject.kind === "surface" || subject.kind === "flow"));
+    if (!roots.length)
+        invalid("manifest_subject_root_required", manifest.target_key);
+    for (const subject of manifest.subjects)
+        validateSubject(subject, subjects, census);
+    validateSubjectParentAcyclic(manifest, subjects);
+}
+function validateSubject(subject, subjects, census) {
+    nonempty(subject.census_refs, `manifest_subject_census_required:${subject.key}`);
+    refsKnown(subject.census_refs, census, "manifest_subject_census_unknown", subject.key);
+    if (subject.presence === "always" && subject.presence_rule_ref !== null)
+        invalid("manifest_always_presence_rule_forbidden", subject.key);
+    if (subject.presence !== "always" && subject.presence_rule_ref === null)
+        invalid("manifest_dynamic_presence_rule_required", subject.key);
+    validatePresenceAndPopulation(subject, census);
+    for (const ref of [
+        subject.parent_ref,
+        subject.instance_of_ref,
+        subject.override_of_ref,
+        subject.family_ref,
+        subject.portal_host_ref,
+    ])
+        if (ref !== null && !subjects.has(ref))
+            invalid("manifest_subject_relation_unknown", `${subject.key}:${ref}`);
+    if (subject.parent_ref === null &&
+        subject.kind !== "surface" &&
+        subject.kind !== "flow")
+        invalid("manifest_subject_parent_required", subject.key);
+    if (subject.presence === "portal" && subject.portal_host_ref === null)
+        invalid("manifest_portal_host_required", subject.key);
+    validateRelationSubject(subject, subjects);
+}
+function validatePresenceAndPopulation(subject, census) {
+    if (subject.presence_rule_ref !== null) {
+        const presenceRule = census.get(subject.presence_rule_ref);
+        if (!presenceRule)
+            invalid("manifest_presence_rule_census_unknown", `${subject.key}:${subject.presence_rule_ref}`);
+        if (!["declaration", "state", "dynamic_population"].includes(presenceRule.kind))
+            invalid("manifest_presence_rule_census_kind_invalid", `${subject.key}:${subject.presence_rule_ref}:${presenceRule.kind}`);
+    }
+    if (subject.presence === "virtualized" && subject.population_ref === null)
+        invalid("manifest_virtualized_population_required", subject.key);
+    if (subject.population_ref === null)
+        return;
+    const population = census.get(subject.population_ref);
+    if (!population)
+        invalid("manifest_population_census_unknown", `${subject.key}:${subject.population_ref}`);
+    if (population.kind !== "dynamic_population")
+        invalid("manifest_population_census_kind_invalid", `${subject.key}:${subject.population_ref}:${population.kind}`);
+}
+function validateRelationSubject(subject, subjects) {
+    if (subject.kind !== "relation") {
+        if (subject.relation_endpoints.length)
+            invalid("manifest_nonrelation_endpoints_forbidden", subject.key);
+        return;
+    }
+    if (subject.relation_endpoints.length < 2)
+        invalid("manifest_relation_endpoints_required", subject.key);
+    unique(subject.relation_endpoints.map((item) => item.role), `manifest_relation_endpoint_role_duplicate:${subject.key}`);
+    for (const endpoint of subject.relation_endpoints)
+        if (endpoint.subject_ref === subject.key ||
+            !subjects.has(endpoint.subject_ref))
+            invalid("manifest_relation_endpoint_invalid", `${subject.key}:${endpoint.role}:${endpoint.subject_ref}`);
+}
+function validateSubjectParentAcyclic(manifest, subjects) {
+    for (const subject of manifest.subjects) {
+        const visited = new Set();
+        let current = subject;
+        while (current?.parent_ref) {
+            if (visited.has(current.key))
+                invalid("manifest_subject_parent_cycle", subject.key);
+            visited.add(current.key);
+            current = subjects.get(current.parent_ref);
+        }
+    }
+}

package/dist/lib/design-resource-fact-universe-variations.d.ts

@@ -0,0 +1,2 @@
+import { type DesignResourceObservableFactManifestV1 } from "./design-resource-fact-manifest-types.js";
+export declare function validateManifestVariationUniverse(manifest: DesignResourceObservableFactManifestV1, census: Map<string, DesignResourceObservableFactManifestV1["inspector"]["census"][number]>, sourceItems: Map<string, string>): void;

package/dist/lib/design-resource-fact-universe-variations.js

@@ -0,0 +1,75 @@
+import { DESIGN_RESOURCE_VARIATION_AXES, } from "./design-resource-fact-manifest-types.js";
+import { axisFingerprint, cartesian, exactAxisPairs, groupBy, invalid, nonempty, refsKnown, sameSet, unique, validateBasis, variationValues, } from "./design-resource-fact-universe-helpers.js";
+export function validateManifestVariationUniverse(manifest, census, sourceItems) {
+    const subjects = new Set(manifest.subjects.map((item) => item.key));
+    const variationsBySubject = groupBy(manifest.variations, (item) => item.subject_ref);
+    const axesBySubject = groupBy(manifest.variation_axis_dispositions, (item) => item.subject_ref);
+    const exclusionsBySubject = groupBy(manifest.variation_exclusions, (item) => item.subject_ref);
+    for (const subjectRef of subjects) {
+        validateSubjectVariations(subjectRef, variationsBySubject.get(subjectRef) ?? [], axesBySubject.get(subjectRef) ?? [], exclusionsBySubject.get(subjectRef) ?? [], census, sourceItems);
+    }
+    for (const ref of [
+        ...variationsBySubject.keys(),
+        ...axesBySubject.keys(),
+        ...exclusionsBySubject.keys(),
+    ])
+        if (!subjects.has(ref))
+            invalid("manifest_variation_subject_unknown", ref);
+}
+function validateSubjectVariations(subjectRef, variations, axes, exclusions, census, sourceItems) {
+    unique(axes.map((axis) => axis.axis), `manifest_variation_axis_duplicate:${subjectRef}`);
+    for (const axis of DESIGN_RESOURCE_VARIATION_AXES)
+        if (!axes.some((item) => item.axis === axis))
+            invalid("manifest_variation_standard_axis_missing", `${subjectRef}:${axis}`);
+    for (const axis of axes)
+        validateVariationAxis(axis, census, sourceItems);
+    const byAxis = new Map(axes.map((axis) => [axis.axis, axis]));
+    const actual = validateVariations(variations, byAxis);
+    const excluded = validateVariationExclusions(exclusions, census, sourceItems, actual);
+    const expected = cartesian(axes.map((axis) => axis.values.map((value) => [axis.axis, value.key]))).map(axisFingerprint);
+    sameSet([...actual.keys(), ...excluded.keys()], expected, "manifest_variation_universe_mismatch", subjectRef);
+    if (!actual.size)
+        invalid("manifest_subject_variation_required", subjectRef);
+}
+function validateVariationAxis(axis, census, sourceItems) {
+    validateBasis(axis, sourceItems, census, `manifest_variation_axis:${axis.key}`);
+    nonempty(axis.values, `manifest_variation_axis_values_required:${axis.key}`);
+    unique(axis.values.map((value) => value.key), `manifest_variation_axis_value_duplicate:${axis.key}`);
+    if (axis.disposition === "not_applicable" &&
+        (axis.values.length !== 1 || axis.values[0].key !== "not-applicable"))
+        invalid("manifest_variation_axis_not_applicable_invalid", axis.key);
+    for (const value of axis.values) {
+        if (axis.disposition === "applicable")
+            nonempty(value.census_refs, `manifest_variation_value_census_required:${axis.key}:${value.key}`);
+        refsKnown(value.census_refs, census, "manifest_variation_value_census_unknown", `${axis.key}:${value.key}`);
+    }
+}
+function validateVariations(variations, byAxis) {
+    const actual = new Map();
+    for (const variation of variations) {
+        const values = variationValues(variation);
+        for (const [axis, value] of values)
+            if (!byAxis.get(axis).values.some((candidate) => candidate.key === value))
+                invalid("manifest_variation_axis_value_unknown", `${variation.key}:${axis}:${value}`);
+        const fingerprint = axisFingerprint(values);
+        if (actual.has(fingerprint))
+            invalid("manifest_variation_combination_duplicate", `${actual.get(fingerprint)}:${variation.key}`);
+        actual.set(fingerprint, variation.key);
+    }
+    return actual;
+}
+function validateVariationExclusions(exclusions, census, sourceItems, actual) {
+    const excluded = new Map();
+    for (const row of exclusions) {
+        validateBasis(row, sourceItems, census, `manifest_variation_exclusion:${row.key}`);
+        if (row.disposition === "decision_required" ||
+            row.disposition === "unavailable")
+            invalid("manifest_variation_exclusion_unresolved", row.key);
+        const values = exactAxisPairs(row.axis_values, [...DESIGN_RESOURCE_VARIATION_AXES], `manifest_variation_exclusion:${row.key}`);
+        const fingerprint = axisFingerprint(values);
+        if (actual.has(fingerprint) || excluded.has(fingerprint))
+            invalid("manifest_variation_exclusion_duplicate", row.key);
+        excluded.set(fingerprint, row.key);
+    }
+    return excluded;
+}

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

@@ -0,0 +1,2 @@
+import type { DesignResourceValueKind } from "./design-resource-fact-manifest-types.js";
+export declare function validateDesignResourceValueKind(kind: DesignResourceValueKind, value: Buffer, label: string): void;

package/dist/lib/design-resource-fact-value-validation.js

@@ -0,0 +1,80 @@
+import { invalidDesignResourceHandoff } from "./design-resource-handoff-validation-primitives.js";
+const VALUE_VALIDATORS = {
+    boolean: (text) => /^(?:true|false)$/u.test(text),
+    color: (text) => !text.includes("|") &&
+        (/^#[a-f0-9]{3,8}$/iu.test(text) ||
+            /^(?:rgb|rgba|hsl|hsla|hwb|lab|lch|oklab|oklch|color|color-mix|light-dark|var)\(.+\)$/iu.test(text) ||
+            /^(?:transparent|currentcolor|[a-z]+)$/iu.test(text)),
+    digest: (text) => /^[a-f0-9]{64}$/u.test(text),
+    enum: (text) => /^[a-z0-9][a-z0-9._:-]*$/iu.test(text),
+    length: (text, structured) => isLength(text, structured),
+    list: (text, structured) => structured === null
+        ? !text.includes("|")
+        : Array.isArray(structured) || typeof structured === "object",
+    locator: () => true,
+    number: (text) => isFiniteNumber(text),
+    ratio: (text, structured) => isRatio(text, structured),
+    relation: (_text, structured) => isStructuredCollection(structured),
+    semantic: (text, structured) => structured !== null || /^[a-z0-9][a-z0-9._:-]*$/iu.test(text),
+    string: () => true,
+    timeline: (_text, structured) => isStructuredCollection(structured),
+    token_ref: (text, structured) => structured !== null ||
+        /^(?:--[a-z0-9_-]+|[a-z0-9][a-z0-9._/-]*)$/iu.test(text),
+    trace: (_text, structured) => isStructuredCollection(structured),
+};
+export function validateDesignResourceValueKind(kind, value, label) {
+    const text = value.toString("utf8").trim();
+    const structured = text ? parseStructuredValue(text) : null;
+    if (!text || !VALUE_VALIDATORS[kind](text, structured)) {
+        invalidDesignResourceHandoff("located_value_kind_mismatch", `${label}:${kind}`);
+    }
+}
+function parseStructuredValue(value) {
+    if (!value.startsWith("{") && !value.startsWith("["))
+        return null;
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return null;
+    }
+}
+function isStructuredCollection(value) {
+    return value !== null && typeof value === "object";
+}
+function isFiniteNumber(value) {
+    if (!/^-?(?:\d+\.?\d*|\.\d+)(?:e[+-]?\d+)?$/iu.test(value))
+        return false;
+    return Number.isFinite(Number(value));
+}
+function isLength(value, structured) {
+    if (structured &&
+        typeof structured === "object" &&
+        !Array.isArray(structured)) {
+        const row = structured;
+        return (typeof row.value === "number" &&
+            Number.isFinite(row.value) &&
+            typeof row.unit === "string" &&
+            /^[a-z%][a-z0-9%_-]*$/iu.test(row.unit));
+    }
+    return (/^(?:0|-?(?:\d+\.?\d*|\.\d+)(?:px|dp|sp|pt|pc|in|cm|mm|q|em|rem|ex|ch|cap|ic|lh|rlh|vw|vh|vi|vb|vmin|vmax|svw|svh|lvw|lvh|dvw|dvh|cqw|cqh|cqi|cqb|cqmin|cqmax|%))$/iu.test(value) ||
+        /^(?:calc|min|max|clamp|fit-content|var|env)\(.+\)$/iu.test(value) ||
+        /^(?:auto|min-content|max-content|stretch|normal|hairline)$/iu.test(value));
+}
+function isRatio(value, structured) {
+    if (isFiniteNumber(value))
+        return true;
+    if (/^-?(?:\d+\.?\d*|\.\d+)\s*\/\s*-?(?:\d+\.?\d*|\.\d+)$/u.test(value))
+        return true;
+    if (Array.isArray(structured)) {
+        return (structured.length === 2 &&
+            structured.every((item) => typeof item === "number" && Number.isFinite(item)));
+    }
+    if (!structured || typeof structured !== "object")
+        return false;
+    const row = structured;
+    return (typeof row.width === "number" &&
+        Number.isFinite(row.width) &&
+        typeof row.height === "number" &&
+        Number.isFinite(row.height));
+}

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

@@ -9,6 +9,8 @@ export function isTextResource(resource) {
         [
             "application/javascript",
             "application/json",
+            "application/typescript",
             "application/xhtml+xml",
+            "image/svg+xml",
         ].includes(resource.media_type));
 }