extension PureXML.Validation.SchemaCompile {
    /// src-resolve: a resolved `include`/`import`/`redefine` `schemaLocation` (one the
    /// loader returned content for) must be a well-formed schema document. The
    /// failures are recorded on the context during composition; an unresolved
    /// location (the loader returned nothing) is not recorded, since resolution is
    /// the processor's choice.
    static var referencedSchemasResolveToSchemas: PureXML.Validation.Validation<PureXML.Schema.SchemaCompileRoot, PureXML.Schema.SchemaCompileContext> {
        compileRule("A resolved schemaLocation reference is a valid schema") { document in
            document.context.failedSchemaReferences.map {
                PureXML.Schema.SchemaLocatedFinding(
                    reason: "the referenced schema document '\($0.location)' is not a valid schema",
                    node: $0.node,
                )
            }
        }
    }

    /// src-redefine.5: every type inside `xs:redefine` must restrict or extend the
    /// type it redefines (same local name, in the redefining schema's own target
    /// namespace).
    static var redefinitionsDeriveFromThemselves: PureXML.Validation.Validation<PureXML.Schema.SchemaCompileRoot, PureXML.Schema.SchemaCompileContext> {
        compileRule("A redefined type restricts or extends itself") { document in
            PureXML.Schema.XSDParser.redefineDerivationFindings(document.containers)
        }
    }

    /// src-redefine.6.1/7.2.1: a redefined group or attribute group has at most one
    /// self-reference, and a group self-reference occurs exactly once.
    static var redefineSelfReferencesAreWellFormed: PureXML.Validation.Validation<PureXML.Schema.SchemaCompileRoot, PureXML.Schema.SchemaCompileContext> {
        compileRule("A redefined group or attribute group has a well-formed self-reference") { document in
            PureXML.Schema.XSDParser.redefineSelfReferenceFindings(document.containers)
        }
    }

    /// src-redefine: a redefinition of an attribute group restricts the original, so
    /// it may not eliminate a required attribute use the original declares.
    static var redefinedAttributeGroupsKeepRequired: PureXML.Validation.Validation<PureXML.Schema.SchemaCompileRoot, PureXML.Schema.SchemaCompileContext> {
        compileRule("A redefined attribute group keeps the original's required attributes") { document in
            PureXML.Schema.XSDParser.redefineAttributeGroupRestrictionFindings(document.containers)
        }
    }

    /// cos-group-restrict: a model group redefined through `xs:redefine` restricts the
    /// original, so its content model must accept a subset of the original's. Reuses
    /// the particle-restriction oracle; runs after named types resolve so element type
    /// compatibility is available.
    static var redefinedGroupsRestrictBase: PureXML.Validation.Validation<PureXML.Schema.SchemaCompileRoot, PureXML.Schema.SchemaCompileContext> {
        compileRule("A redefined model group restricts the group it redefines") { document in
            guard let namedTypes = document.namedTypes, let derivation = document.derivation else { return [] }
            return PureXML.Schema.XSDParser.redefineGroupRestrictionFindings(
                document.containers,
                context: document.context,
                types: namedTypes,
                derivation: derivation.typeDerivation,
            )
        }
    }

    /// Facet definition validity and pattern syntax validity (XSD Part 2 4.3): a
    /// constraining facet must be applicable to and valid for its base type, and a
    /// `pattern` must compile. These are gathered during simple-type compilation
    /// (where the resolved base type is available) into the context's finding sink,
    /// then surfaced here as a named, located validation rather than reported
    /// straight to the diagnostics collector during parsing.
    static var simpleTypeFacetsAreValid: PureXML.Validation.Validation<PureXML.Schema.SchemaCompileRoot, PureXML.Schema.SchemaCompileContext> {
        compileRule("Simple-type facets are valid for their base type") { document in
            document.context.facetFindingSink.findings
        }
    }
}