#include <concepts>
#include <memory>
#include <type_traits>
#include <utility>

#include <catch2/catch_test_macros.hpp>
#include <mfem.hpp>

import mean_field;

namespace stellar_runtime_contract_test {
    template <mean_field::model::StellarModelType Model> class PreparedMissingRieszScalarConstraint;

    template <mean_field::model::StellarModelType Model> class PreparedSecondRotationController;

    template <mean_field::model::StellarModelType Model> class PreparedRawNestedProtocolConstraint;

    struct NonDefaultRuntimeReport final {
        NonDefaultRuntimeReport() = delete;
        explicit constexpr NonDefaultRuntimeReport(const bool changed) noexcept : m_changed(changed) {
        }

        [[nodiscard]] constexpr bool DidAnyWork() const noexcept {
            return m_changed;
        }

    private:
        bool m_changed;
    };

    struct NonAssignableRuntimeReport final {
        constexpr NonAssignableRuntimeReport() noexcept                           = default;
        NonAssignableRuntimeReport(const NonAssignableRuntimeReport &)            = default;
        NonAssignableRuntimeReport(NonAssignableRuntimeReport &&)                 = default;
        NonAssignableRuntimeReport &operator=(const NonAssignableRuntimeReport &) = delete;
        NonAssignableRuntimeReport &operator=(NonAssignableRuntimeReport &&)      = delete;

        [[nodiscard]] constexpr bool DidAnyWork() const noexcept {
            return false;
        }
    };

    /* Deliberately carries no framework-specific work-reporting method.  A
     * third-party report is storage for its author's diagnostics, not an input to
     * residual-cache correctness. */
    struct OpaqueRuntimeReport final {
        bool prepared{true};
    };

    template <mean_field::model::StellarModelType Model, typename ReportType>
    class PreparedReportContractRuntime final {
    public:
        using Report = ReportType;

        template <mean_field::models::ModelSpecification Specification>
        explicit PreparedReportContractRuntime(const Specification &) noexcept {
        }

        template <typename StateView> [[nodiscard]] Report PrepareAfterPhysical(const StateView &) noexcept {
            if constexpr (std::default_initializable<Report>) {
                return {};
            } else {
                return Report{false};
            }
        }

        template <
            typename Equation,
            typename Row>
        [[nodiscard]] mean_field::stellar::StructuralZero AddResidual(
            Equation,
            Row &
        ) const noexcept {
            return mean_field::stellar::structuralZero;
        }

        template <
            typename Equation,
            typename State,
            typename Direction,
            typename Row>
        [[nodiscard]] mean_field::stellar::StructuralZero AddJacobianAction(
            mean_field::stellar::Derivative<
                Equation,
                State>,
            const Direction &,
            Row &
        ) const noexcept {
            return mean_field::stellar::zeroDerivative;
        }

        [[nodiscard]] constexpr bool IsPrepared() const noexcept {
            return true;
        }
    };

    template <mean_field::model::StellarModelType Model>
    using PreparedNonDefaultReportRuntime = PreparedReportContractRuntime<Model, NonDefaultRuntimeReport>;

    template <mean_field::model::StellarModelType Model>
    using PreparedNonAssignableReportRuntime = PreparedReportContractRuntime<Model, NonAssignableRuntimeReport>;

    template <mean_field::model::StellarModelType Model>
    using PreparedOpaqueReportRuntime = PreparedReportContractRuntime<Model, OpaqueRuntimeReport>;

    template <mean_field::model::StellarModelType Model>
    using PreparedAmbiguousRegistrationRuntime =
        PreparedReportContractRuntime<Model, mean_field::operators::EmptySpecificationPreparationReport>;

    struct NonDefaultReportConstraint final {
        struct Parameters final {
            mean_field::dimensions::SpecificEnthalpyValue target;
        };

        using ScalarDescription = mean_field::stellar::ScalarConstraint<
            mean_field::dimensions::quantity::SpecificEnthalpy,
            mean_field::dimensions::quantity::SpecificEnthalpy,
            mean_field::dimensions::quantity::SpecificEnthalpy,
            "runtime.non_default.value",
            "lambda_nd",
            "runtime.non_default.residual",
            "R_nd">;
        using ModelDefinition = mean_field::constraint::ScalarPhaseCondition<
            NonDefaultReportConstraint,
            "NonDefaultReportConstraint",
            mean_field::stellar::Reads<mean_field::stellar::state::SpecificEnthalpy>,
            mean_field::stellar::Changes<mean_field::stellar::equation::HydrostaticBalance>,
            ScalarDescription>;
        using EquilibriumPhysics =
            mean_field::operators::SpecificationEquilibriumPhysics<PreparedNonDefaultReportRuntime>;

        explicit constexpr NonDefaultReportConstraint(Parameters parameters) noexcept : m_target(parameters.target) {
        }
        [[nodiscard]] constexpr auto target() const noexcept {
            return m_target;
        }

    private:
        mean_field::dimensions::SpecificEnthalpyValue m_target;
    };

    struct NonAssignableReportConstraint final {
        struct Parameters final {
            mean_field::dimensions::SpecificEnthalpyValue target;
        };

        using ScalarDescription = mean_field::stellar::ScalarConstraint<
            mean_field::dimensions::quantity::SpecificEnthalpy,
            mean_field::dimensions::quantity::SpecificEnthalpy,
            mean_field::dimensions::quantity::SpecificEnthalpy,
            "runtime.non_assignable.value",
            "lambda_na",
            "runtime.non_assignable.residual",
            "R_na">;
        using ModelDefinition = mean_field::constraint::ScalarPhaseCondition<
            NonAssignableReportConstraint,
            "NonAssignableReportConstraint",
            mean_field::stellar::Reads<mean_field::stellar::state::SpecificEnthalpy>,
            mean_field::stellar::Changes<mean_field::stellar::equation::HydrostaticBalance>,
            ScalarDescription>;
        using EquilibriumPhysics =
            mean_field::operators::SpecificationEquilibriumPhysics<PreparedNonAssignableReportRuntime>;

        explicit constexpr NonAssignableReportConstraint(Parameters parameters) noexcept : m_target(parameters.target) {
        }
        [[nodiscard]] constexpr auto target() const noexcept {
            return m_target;
        }

    private:
        mean_field::dimensions::SpecificEnthalpyValue m_target;
    };

    struct OpaqueReportConstraint final {
        struct Parameters final {
            mean_field::dimensions::SpecificEnthalpyValue target;
        };

        using ScalarDescription = mean_field::stellar::ScalarConstraint<
            mean_field::dimensions::quantity::SpecificEnthalpy,
            mean_field::dimensions::quantity::SpecificEnthalpy,
            mean_field::dimensions::quantity::SpecificEnthalpy,
            "runtime.opaque.value",
            "lambda_opaque",
            "runtime.opaque.residual",
            "R_opaque">;
        using ModelDefinition = mean_field::constraint::ScalarPhaseCondition<
            OpaqueReportConstraint,
            "OpaqueReportConstraint",
            mean_field::stellar::Reads<mean_field::stellar::state::SpecificEnthalpy>,
            mean_field::stellar::Changes<mean_field::stellar::equation::HydrostaticBalance>,
            ScalarDescription>;
        using EquilibriumPhysics = mean_field::operators::SpecificationEquilibriumPhysics<PreparedOpaqueReportRuntime>;

        explicit constexpr OpaqueReportConstraint(Parameters parameters) noexcept : m_target(parameters.target) {
        }
        [[nodiscard]] constexpr auto target() const noexcept {
            return m_target;
        }

    private:
        mean_field::dimensions::SpecificEnthalpyValue m_target;
    };

    /* This fixture implements the former nested protocol verbatim.  It is a
     * physics-facing declaration, so raw backend access must not make it an
     * executable contribution. */
    struct RawNestedProtocolConstraint final {
        struct Parameters final {
            mean_field::dimensions::SpecificEnthalpyValue target;
        };

        using ScalarDescription = mean_field::stellar::ScalarConstraint<
            mean_field::dimensions::quantity::SpecificEnthalpy,
            mean_field::dimensions::quantity::SpecificEnthalpy,
            mean_field::dimensions::quantity::SpecificEnthalpy,
            "runtime.raw.value",
            "lambda_raw",
            "runtime.raw.residual",
            "R_raw">;
        using ModelDefinition = mean_field::constraint::ScalarPhaseCondition<
            RawNestedProtocolConstraint,
            "RawNestedProtocolConstraint",
            mean_field::stellar::Reads<mean_field::stellar::state::SpecificEnthalpy>,
            mean_field::stellar::Changes<mean_field::stellar::equation::HydrostaticBalance>,
            ScalarDescription>;
        using EquilibriumPhysics =
            mean_field::operators::SpecificationEquilibriumPhysics<PreparedRawNestedProtocolConstraint>;

        explicit constexpr RawNestedProtocolConstraint(Parameters parameters) noexcept : m_target(parameters.target) {
        }
        [[nodiscard]] constexpr auto target() const noexcept {
            return m_target;
        }

    private:
        mean_field::dimensions::SpecificEnthalpyValue m_target;
    };

    struct AmbiguousRuntimeRegistrationConstraint final {
        struct Parameters final {
            mean_field::dimensions::SpecificEnthalpyValue target;
        };

        using ScalarDescription = mean_field::stellar::ScalarConstraint<
            mean_field::dimensions::quantity::SpecificEnthalpy,
            mean_field::dimensions::quantity::SpecificEnthalpy,
            mean_field::dimensions::quantity::SpecificEnthalpy,
            "runtime.ambiguous.value",
            "lambda_ar",
            "runtime.ambiguous.residual",
            "R_ar">;
        using ModelDefinition = mean_field::constraint::ScalarPhaseCondition<
            AmbiguousRuntimeRegistrationConstraint,
            "AmbiguousRuntimeRegistrationConstraint",
            mean_field::stellar::Reads<mean_field::stellar::state::SpecificEnthalpy>,
            mean_field::stellar::Changes<mean_field::stellar::equation::HydrostaticBalance>,
            ScalarDescription>;
        using EquilibriumPhysics =
            mean_field::operators::SpecificationEquilibriumPhysics<PreparedAmbiguousRegistrationRuntime>;

        explicit constexpr AmbiguousRuntimeRegistrationConstraint(Parameters parameters) noexcept
            : m_target(parameters.target) {
        }
        [[nodiscard]] constexpr auto target() const noexcept {
            return m_target;
        }

    private:
        mean_field::dimensions::SpecificEnthalpyValue m_target;
    };

    /* A complete aggregate backend candidate with no nested provider. Its raw
     * registration is deliberately not authorized by the built-in concrete core,
     * so the runtime capability must reject it at exactly that boundary. */
    struct UnauthorizedAggregateConstraint final {
        struct Parameters final {
            mean_field::dimensions::SpecificEnthalpyValue target;
        };

        using ScalarDescription = mean_field::stellar::ScalarConstraint<
            mean_field::dimensions::quantity::SpecificEnthalpy,
            mean_field::dimensions::quantity::SpecificEnthalpy,
            mean_field::dimensions::quantity::SpecificEnthalpy,
            "runtime.unauthorized.value",
            "lambda_unauthorized",
            "runtime.unauthorized.residual",
            "R_unauthorized">;
        using ModelDefinition = mean_field::constraint::ScalarPhaseCondition<
            UnauthorizedAggregateConstraint,
            "UnauthorizedAggregateConstraint",
            mean_field::stellar::Reads<mean_field::stellar::state::SpecificEnthalpy>,
            mean_field::stellar::Changes<mean_field::stellar::equation::HydrostaticBalance>,
            ScalarDescription>;

        explicit constexpr UnauthorizedAggregateConstraint(Parameters parameters) noexcept
            : m_target(parameters.target) {
        }

        [[nodiscard]] constexpr auto target() const noexcept {
            return m_target;
        }

    private:
        mean_field::dimensions::SpecificEnthalpyValue m_target;
    };

    struct RegisteredWithoutMakeEquationOfState final {
        struct Parameters final { };

        using ModelDefinition = mean_field::models::
            ConstitutiveLaw<RegisteredWithoutMakeEquationOfState, "RegisteredWithoutMakeEquationOfState">;

        explicit RegisteredWithoutMakeEquationOfState(Parameters) noexcept {
        }
    };

    struct IncompleteSurfaceRuntime final {
        struct Parameters final { };

        using ModelDefinition =
            mean_field::surface::BoundaryCondition<IncompleteSurfaceRuntime, "IncompleteSurfaceRuntime">;

        explicit IncompleteSurfaceRuntime(Parameters) noexcept {
        }
    };

    /*
     * This constraint is executable and has complete diagnostic metadata, but it
     * deliberately omits its generated-coordinate Physical Riesz declaration.
     * It isolates model/discretization compatibility from every other runtime
     * capability in the rejection-boundary tests below.
     */
    struct MissingRieszScalarConstraint final {
        struct Parameters final {
            mean_field::dimensions::MassValue target;
        };

        using TargetValue     = mean_field::dimensions::MassValue;
        using ModelDefinition = mean_field::integral::FixedIntegralWithMultiplier<
            MissingRieszScalarConstraint,
            "MissingRieszScalarConstraint",
            mean_field::models::DependsOn<mean_field::models::stellar::state::Density>,
            mean_field::models::Affects<mean_field::models::stellar::equation::HydrostaticBalance>,
            mean_field::models::UnavailableGeneratedNormalization,
            mean_field::models::GeneratedManifest<
                "missing_riesz.multiplier",
                "lambda_mr",
                "missing_riesz.residual",
                "R_mr",
                "mass",
                "mass">>;
        using EquilibriumPhysics =
            mean_field::operators::SpecificationEquilibriumPhysics<PreparedMissingRieszScalarConstraint>;

        explicit MissingRieszScalarConstraint(Parameters parameters) noexcept : m_target(parameters.target) {
        }

        [[nodiscard]] TargetValue target() const noexcept {
            return m_target;
        }

    private:
        TargetValue m_target;
    };

    /* A second, independently inferred rotation source.  Its numerical runtime is
     * otherwise complete; pairing it with FixedAngularMomentum must fail solely
     * because a physical model cannot have two owners for the generated rotation
     * control. */
    struct SecondRotationController final {
        struct Parameters final {
            mean_field::dimensions::SpecificEnthalpyValue target;
        };

        using TargetValue     = mean_field::dimensions::SpecificEnthalpyValue;
        using ModelDefinition = mean_field::constraint::PhaseCondition<
            SecondRotationController,
            "SecondRotationController",
            mean_field::models::DependsOn<mean_field::models::stellar::state::SpecificEnthalpy>,
            mean_field::models::Affects<mean_field::models::stellar::equation::HydrostaticBalance>,
            mean_field::models::GlobalScalarNormalization<
                mean_field::models::PhysicalScaleLaw::specific_energy,
                mean_field::models::PhysicalScaleLaw::specific_energy>,
            mean_field::models::GeneratedManifest<
                "second_rotation.control",
                "omega_2",
                "second_rotation.residual",
                "R_omega_2",
                "specific_enthalpy",
                "specific_enthalpy">>;
        using EquilibriumPhysics =
            mean_field::operators::SpecificationEquilibriumPhysics<PreparedSecondRotationController, 1>;

        explicit SecondRotationController(Parameters parameters) noexcept : m_target(parameters.target) {
        }

        [[nodiscard]] TargetValue target() const noexcept {
            return m_target;
        }

    private:
        TargetValue m_target;
    };

    struct AlternateCoreEquationOfState final {
        struct Parameters final { };

        using ModelDefinition =
            mean_field::models::ConstitutiveLaw<AlternateCoreEquationOfState, "AlternateCoreEquationOfState">;
        using Relations = mean_field::eos::RelationCatalog<mean_field::eos::SpecificEnthalpyFromPressure>;

        explicit AlternateCoreEquationOfState(Parameters) noexcept {
        }

        [[nodiscard]] mean_field::dimensions::SpecificEnthalpyValue evaluate(
            mean_field::eos::SpecificEnthalpyFromPressure,
            mean_field::dimensions::PressureValue
        ) const;
    };

    struct WrongOwnerEquationOfState final {
        struct Parameters final { };

        using ModelDefinition =
            mean_field::models::ConstitutiveLaw<WrongOwnerEquationOfState, "WrongOwnerEquationOfState">;

        explicit WrongOwnerEquationOfState(Parameters) noexcept {
        }
    };

    /*
     * A deliberately tiny alternate core.  No MFEM stellar assembly is needed:
     * this type exists to prove that the extension protocol is structural and
     * does not name the Polytrope implementation.
     */
    class AlternatePhysicalCore : public mfem::Operator {
    public:
        using BackendSpecifications = mean_field::models::ModelTypeList<
            AlternateCoreEquationOfState,
            WrongOwnerEquationOfState,
            mean_field::surface::Isobaric,
            mean_field::models::FixedTotalMass,
            mean_field::models::FixedAngularMomentum,
            AmbiguousRuntimeRegistrationConstraint>;

        using mfem::Operator::Operator;

        void Mult(
            const mfem::Vector &,
            mfem::Vector &
        ) const override;

        [[nodiscard]] const mean_field::operators::StellarEquilibriumLayout &GetLayout() const noexcept;

        [[nodiscard]] mean_field::operators::PreparedStellarEquilibriumReport Prepare(
            const mfem::Vector &,
            const mean_field::operators::StellarEquilibriumDependencies &,
            const mean_field::physics::RigidRotation &
        );

        void BuildResidual(mfem::Vector &) const;
        [[nodiscard]] bool IsPrepared() const noexcept;
        [[nodiscard]] mean_field::operators::RootConstraintReport GetFixedMassReport() const;
        [[nodiscard]] const mean_field::operators::StellarEquilibriumDependencies &GetDependencies() const;
        [[nodiscard]] const mean_field::operators::StellarEquilibriumDependencyStamp &
        GetGeneratedDisplacementDependency() const;
        [[nodiscard]] const mean_field::operators::PreparedPressureSurfaceConstraint &
        GetSurfaceConstraintOperator() const;
    };

    class PhysicalRieszGravityContext final {
    public:
        [[nodiscard]] const mean_field::field::FieldDofMap &GetDensityMap() const noexcept;
        [[nodiscard]] const mean_field::field::FieldDofMap &GetGravityGradientMap() const noexcept;
        [[nodiscard]] const mean_field::field::FieldDofMap &GetGravityPotentialMap() const noexcept;
    };

    class PhysicalRieszHydrostaticOperator final {
    public:
        [[nodiscard]] const mean_field::field::FieldDofMap &GetEnthalpyMap() const noexcept;
    };

    class PhysicalRieszDomainDeformation final {
    public:
        [[nodiscard]] int parameterCount() const noexcept;
    };

    /*
     * Declaration-only opt-in mock: the normalization capability is structural,
     * so none of the heavyweight MFEM physical assembly needs to be constructed
     * to prove that a distinct core can satisfy it.
     */
    class PhysicalRieszCapableCore final : public AlternatePhysicalCore {
    public:
        using AlternatePhysicalCore::AlternatePhysicalCore;

        [[nodiscard]] const PhysicalRieszGravityContext &GetGravityContext() const noexcept;
        [[nodiscard]] const PhysicalRieszHydrostaticOperator &GetHydrostaticOperator() const noexcept;
        [[nodiscard]] const PhysicalRieszDomainDeformation &GetDomainDeformation() const noexcept;
    };

    template <mean_field::model::StellarModelType Model> class AlternateEquationOfStateRuntime final {
    public:
        using Report = mean_field::operators::EmptySpecificationPreparationReport;

        AlternateEquationOfStateRuntime(
            mean_field::fem::FEM &,
            const mean_field::mapping::DomainMapper &,
            AlternatePhysicalCore &,
            const Model &
        ) noexcept {
        }

        template <
            typename StateView,
            typename Controls>
        void ReadPhysicalControls(
            const StateView &,
            Controls &
        ) noexcept {
        }

        template <typename StateView>
        [[nodiscard]] Report PrepareAfterPhysical(
            const StateView &,
            const mean_field::operators::StellarEquilibriumDependencies &,
            const AlternatePhysicalCore &
        ) noexcept {
            return {};
        }

        template <typename ResidualView> void AddResidual(const ResidualView &) const noexcept {
        }

        template <
            typename DirectionView,
            typename ActionView>
        void AddJacobianAction(
            const DirectionView &,
            const ActionView &,
            const AlternatePhysicalCore &
        ) const noexcept {
        }

        [[nodiscard]] bool IsPrepared() const noexcept {
            return true;
        }
    };

    template <mean_field::model::StellarModelType Model> class IncompletePreparedSurfaceRuntime final {
    public:
        struct Report final {
            [[nodiscard]] constexpr bool DidAnyWork() const noexcept {
                return false;
            }
        };

        IncompletePreparedSurfaceRuntime(
            mean_field::fem::FEM &,
            const mean_field::mapping::DomainMapper &,
            mean_field::operators::PreparedStellarEquilibriumOperator &,
            const Model &
        ) noexcept {
        }

        // Intentionally omits the preparation and operator-action interface.
    };

    template <mean_field::model::StellarModelType Model> class PreparedMissingRieszScalarConstraint final {
    public:
        using Report = mean_field::operators::EmptySpecificationPreparationReport;

        explicit PreparedMissingRieszScalarConstraint(const MissingRieszScalarConstraint &) noexcept {
        }

        template <typename StateView> [[nodiscard]] Report PrepareAfterPhysical(const StateView &) noexcept {
            return {};
        }

        template <
            typename Equation,
            typename Row>
        [[nodiscard]] mean_field::stellar::StructuralZero AddResidual(
            Equation,
            Row &
        ) const noexcept {
            return mean_field::stellar::structuralZero;
        }

        template <
            typename Equation,
            typename State,
            typename Direction,
            typename Row>
        [[nodiscard]] mean_field::stellar::StructuralZero AddJacobianAction(
            mean_field::stellar::Derivative<
                Equation,
                State>,
            const Direction &,
            Row &
        ) const noexcept {
            return mean_field::stellar::zeroDerivative;
        }

        [[nodiscard]] constexpr bool IsPrepared() const noexcept {
            return true;
        }
    };

    template <mean_field::model::StellarModelType Model> class PreparedSecondRotationController final {
    public:
        using Report = mean_field::operators::EmptySpecificationPreparationReport;

        explicit PreparedSecondRotationController(const SecondRotationController &) noexcept {
        }

        template <typename StateView>
        [[nodiscard]] mean_field::physics::RigidRotation GenerateRotation(const StateView &) const {
            mfem::Vector angularVelocity(3);
            mfem::Vector center(3);
            angularVelocity = 0.0;
            center          = 0.0;
            return {angularVelocity, center};
        }

        template <typename StateView> [[nodiscard]] Report PrepareAfterPhysical(const StateView &) noexcept {
            return {};
        }

        template <
            typename Equation,
            typename Row>
        [[nodiscard]] mean_field::stellar::StructuralZero AddResidual(
            Equation,
            Row &
        ) const noexcept {
            return mean_field::stellar::structuralZero;
        }

        template <
            typename Equation,
            typename State,
            typename Direction,
            typename Row>
        [[nodiscard]] mean_field::stellar::StructuralZero AddJacobianAction(
            mean_field::stellar::Derivative<
                Equation,
                State>,
            const Direction &,
            Row &
        ) const noexcept {
            return mean_field::stellar::zeroDerivative;
        }

        [[nodiscard]] constexpr bool IsPrepared() const noexcept {
            return true;
        }
    };

    template <mean_field::model::StellarModelType Model> class PreparedRawNestedProtocolConstraint final {
    public:
        using Report = OpaqueRuntimeReport;

        template <mean_field::operators::PreparedStellarEquilibriumPhysicalCore Core>
        PreparedRawNestedProtocolConstraint(
            mean_field::fem::FEM &,
            const mean_field::mapping::DomainMapper &,
            Core &,
            const Model &
        ) noexcept {
        }

        template <
            typename StateView,
            typename Controls>
        void ReadPhysicalControls(
            const StateView &,
            Controls &
        ) noexcept {
        }

        template <
            typename StateView,
            mean_field::operators::PreparedStellarEquilibriumPhysicalCore Core>
        [[nodiscard]] Report PrepareAfterPhysical(
            const StateView &,
            const mean_field::operators::StellarEquilibriumDependencies &,
            const Core &
        ) noexcept {
            return {};
        }

        template <typename ResidualView> void AddResidual(const ResidualView &) const noexcept {
        }

        template <
            typename DirectionView,
            typename ActionView,
            mean_field::operators::PreparedStellarEquilibriumPhysicalCore Core>
        void AddJacobianAction(
            const DirectionView &,
            const ActionView &,
            const Core &
        ) const noexcept {
        }

        [[nodiscard]] constexpr bool IsPrepared() const noexcept {
            return true;
        }
    };
} // namespace stellar_runtime_contract_test

namespace mean_field::operators {
    template <>
    struct StellarEquilibriumCoreRuntime<stellar_runtime_contract_test::RegisteredWithoutMakeEquationOfState> {
        static constexpr bool registered = true;
        // Intentionally no Make(). Capability follows the callable interface.
    };

    template <> struct StellarEquilibriumCoreRuntime<stellar_runtime_contract_test::AlternateCoreEquationOfState> {
        static constexpr bool registered = true;
        using CoreType                   = stellar_runtime_contract_test::AlternatePhysicalCore;

        [[nodiscard]] static std::unique_ptr<CoreType> Make(
            fem::FEM &,
            const mapping::DomainMapper &,
            const stellar_runtime_contract_test::AlternateCoreEquationOfState &,
            const models::CompiledFixedMass &,
            PressureSurfaceConstraintView,
            deformation::PreparedDomainDeformationRuntime
        );

        [[nodiscard]] static int SurfaceEquationCount(const CoreType &) noexcept;
    };

    template <>
    struct StellarEquilibriumRuntimeContribution<stellar_runtime_contract_test::AlternateCoreEquationOfState>
        : PreparedStellarEquilibriumContribution<stellar_runtime_contract_test::AlternateEquationOfStateRuntime> { };

    template <> struct StellarEquilibriumCoreRuntime<stellar_runtime_contract_test::WrongOwnerEquationOfState> {
        static constexpr bool registered = true;
        using CoreType                   = stellar_runtime_contract_test::AlternatePhysicalCore;

        // Intentionally owns the Polytrope core instead of the advertised type.
        [[nodiscard]] static std::unique_ptr<PreparedStellarEquilibriumOperator> Make(
            fem::FEM &,
            const mapping::DomainMapper &,
            const stellar_runtime_contract_test::WrongOwnerEquationOfState &,
            const models::CompiledFixedMass &,
            PressureSurfaceConstraintView,
            deformation::PreparedDomainDeformationRuntime
        );

        [[nodiscard]] static int SurfaceEquationCount(const CoreType &) noexcept;
    };

    template <>
    struct StellarEquilibriumRuntimeContribution<stellar_runtime_contract_test::WrongOwnerEquationOfState>
        : PreparedStellarEquilibriumContribution<stellar_runtime_contract_test::AlternateEquationOfStateRuntime> { };

    template <>
    struct StellarEquilibriumRuntimeContribution<stellar_runtime_contract_test::IncompleteSurfaceRuntime>
        : PreparedStellarEquilibriumContribution<stellar_runtime_contract_test::IncompletePreparedSurfaceRuntime> { };

    template <>
    struct StellarEquilibriumRuntimeContribution<stellar_runtime_contract_test::UnauthorizedAggregateConstraint>
        : PreparedStellarEquilibriumContribution<stellar_runtime_contract_test::PreparedRawNestedProtocolConstraint> {
    };

    /* Deliberately duplicates the constraint's nested package. Whether that is an
     * ambiguity depends on the selected core's own privileged allow-list. */
    template <>
    struct StellarEquilibriumRuntimeContribution<stellar_runtime_contract_test::AmbiguousRuntimeRegistrationConstraint>
        : PreparedStellarEquilibriumContribution<stellar_runtime_contract_test::AlternateEquationOfStateRuntime> { };

} // namespace mean_field::operators

namespace {
    using namespace mean_field;

    using BaseModel =
        model::StellarModel<models::SpecificationSet<eos::Polytrope, surface::Isobaric, models::FixedTotalMass>>;

    using CentralDensityModel = model::StellarModel<
        models::
            SpecificationSet<eos::Polytrope, surface::Isobaric, models::FixedTotalMass, models::FixedCentralDensity>>;

    using AngularMomentumModel = model::StellarModel<
        models::
            SpecificationSet<eos::Polytrope, surface::Isobaric, models::FixedTotalMass, models::FixedAngularMomentum>>;

    using AngularCentralDensityModel  = model::StellarModel<models::SpecificationSet<
        eos::Polytrope,
        surface::Isobaric,
        models::FixedTotalMass,
        models::FixedAngularMomentum,
        models::FixedCentralDensity>>;

    using DensityValue                = utils::blocks::density::mass::value;
    using SurfaceValue                = utils::blocks::surface_deformation::parameters::value;
    using GravityGradientValue        = utils::blocks::gravity::gradient::value;
    using GravityPotentialValue       = utils::blocks::gravity::poisson::value;
    using EnthalpyValue               = utils::blocks::enthalpy::specific::value;
    using MassValue                   = utils::blocks::fixed_total_mass::mass_normalization::value;
    using AngularVelocityValue        = utils::blocks::fixed_angular_momentum::angular_velocity::value;
    using CentralDensityValue         = utils::blocks::fixed_central_density::central_value::value;

    using GravityGradientResidual     = utils::blocks::gravity::gradient::residual;
    using GravityPotentialResidual    = utils::blocks::gravity::poisson::residual;
    using DensityResidual             = utils::blocks::density::mass::residual;
    using SurfaceResidual             = utils::blocks::surface_deformation::shape_equilibrium::residual;
    using EnthalpyResidual            = utils::blocks::enthalpy::specific::residual;
    using MassResidual                = utils::blocks::fixed_total_mass::mass_normalization::residual;
    using AngularMomentumResidual     = utils::blocks::fixed_angular_momentum::angular_velocity::residual;
    using CentralDensityResidual      = utils::blocks::fixed_central_density::central_value::residual;

    using ExpectedAngularMomentumForm = utils::blocks::block_form<
        utils::blocks::type_list<
            DensityValue,
            SurfaceValue,
            GravityGradientValue,
            GravityPotentialValue,
            EnthalpyValue,
            MassValue,
            AngularVelocityValue>,
        utils::blocks::type_list<
            GravityGradientResidual,
            GravityPotentialResidual,
            DensityResidual,
            SurfaceResidual,
            EnthalpyResidual,
            MassResidual,
            AngularMomentumResidual>>;

    using ExpectedAngularMomentumJacobian = utils::blocks::type_list<
        utils::blocks::block_row<GravityGradientResidual, GravityGradientValue, GravityPotentialValue, SurfaceValue>,
        utils::blocks::block_row<GravityPotentialResidual, GravityGradientValue, DensityValue, SurfaceValue>,
        utils::blocks::block_row<DensityResidual, DensityValue, EnthalpyValue, SurfaceValue>,
        utils::blocks::block_row<
            SurfaceResidual,
            DensityValue,
            SurfaceValue,
            GravityGradientValue,
            EnthalpyValue,
            AngularVelocityValue>,
        utils::blocks::block_row<
            EnthalpyResidual,
            EnthalpyValue,
            GravityPotentialValue,
            SurfaceValue,
            DensityValue,
            MassValue,
            AngularVelocityValue>,
        utils::blocks::block_row<MassResidual, DensityValue, SurfaceValue>,
        utils::blocks::block_row<AngularMomentumResidual, DensityValue, SurfaceValue, AngularVelocityValue>>;

    using ExpectedAngularCentralDensityForm = utils::blocks::block_form<
        utils::blocks::type_list<
            DensityValue,
            SurfaceValue,
            GravityGradientValue,
            GravityPotentialValue,
            EnthalpyValue,
            MassValue,
            AngularVelocityValue,
            CentralDensityValue>,
        utils::blocks::type_list<
            GravityGradientResidual,
            GravityPotentialResidual,
            DensityResidual,
            SurfaceResidual,
            EnthalpyResidual,
            MassResidual,
            AngularMomentumResidual,
            CentralDensityResidual>>;

    using ExpectedAngularCentralDensityJacobian = utils::blocks::type_list<
        utils::blocks::block_row<GravityGradientResidual, GravityGradientValue, GravityPotentialValue, SurfaceValue>,
        utils::blocks::block_row<GravityPotentialResidual, GravityGradientValue, DensityValue, SurfaceValue>,
        utils::blocks::block_row<DensityResidual, DensityValue, EnthalpyValue, SurfaceValue>,
        utils::blocks::block_row<
            SurfaceResidual,
            DensityValue,
            SurfaceValue,
            GravityGradientValue,
            EnthalpyValue,
            AngularVelocityValue>,
        utils::blocks::block_row<
            EnthalpyResidual,
            EnthalpyValue,
            GravityPotentialValue,
            SurfaceValue,
            DensityValue,
            MassValue,
            AngularVelocityValue,
            CentralDensityValue>,
        utils::blocks::block_row<MassResidual, DensityValue, SurfaceValue>,
        utils::blocks::block_row<AngularMomentumResidual, DensityValue, SurfaceValue, AngularVelocityValue>,
        utils::blocks::block_row<CentralDensityResidual, EnthalpyValue>>;

    using MissingMassModel           = model::StellarModel<models::SpecificationSet<eos::Polytrope, surface::Isobaric>>;

    using RegisteredWithoutMakeModel = model::StellarModel<models::SpecificationSet<
        stellar_runtime_contract_test::RegisteredWithoutMakeEquationOfState,
        surface::Isobaric,
        models::FixedTotalMass>>;

    using AlternateCoreModel         = model::StellarModel<models::SpecificationSet<
        stellar_runtime_contract_test::AlternateCoreEquationOfState,
        surface::Isobaric,
        models::FixedTotalMass>>;

    using AlternateCoreAngularMomentumModel = model::StellarModel<models::SpecificationSet<
        stellar_runtime_contract_test::AlternateCoreEquationOfState,
        surface::Isobaric,
        models::FixedTotalMass,
        models::FixedAngularMomentum>>;

    using MissingRieszModel                 = model::StellarModel<models::SpecificationSet<
        eos::Polytrope,
        surface::Isobaric,
        models::FixedTotalMass,
        stellar_runtime_contract_test::MissingRieszScalarConstraint>>;

    using TwoRotationProvidersModel         = model::StellarModel<models::SpecificationSet<
        eos::Polytrope,
        surface::Isobaric,
        models::FixedTotalMass,
        models::FixedAngularMomentum,
        stellar_runtime_contract_test::SecondRotationController>>;

    using NonDefaultReportModel             = model::StellarModel<models::SpecificationSet<
        eos::Polytrope,
        surface::Isobaric,
        models::FixedTotalMass,
        stellar_runtime_contract_test::NonDefaultReportConstraint>>;

    using NonAssignableReportModel          = model::StellarModel<models::SpecificationSet<
        eos::Polytrope,
        surface::Isobaric,
        models::FixedTotalMass,
        stellar_runtime_contract_test::NonAssignableReportConstraint>>;

    using OpaqueReportModel                 = model::StellarModel<models::SpecificationSet<
        eos::Polytrope,
        surface::Isobaric,
        models::FixedTotalMass,
        stellar_runtime_contract_test::OpaqueReportConstraint>>;

    using RawNestedProtocolModel            = model::StellarModel<models::SpecificationSet<
        eos::Polytrope,
        surface::Isobaric,
        models::FixedTotalMass,
        stellar_runtime_contract_test::RawNestedProtocolConstraint>>;

    /*
     * Focused fixtures for the exact physics-provider contract.  Every class is
     * constructible from the same valid specification, so a failed provider
     * concept below can only come from its residual/Jacobian overload set.
     *
     * RawNestedProtocolConstraint declares one owned constraint row, one changed
     * physical row, one read physical state, and one owned generated coordinate.
     * The compiler therefore requires exactly two residual providers and three
     * derivative providers.
     */
    class CompleteExplicitZeroProvider final {
    public:
        explicit CompleteExplicitZeroProvider(
            const stellar_runtime_contract_test::RawNestedProtocolConstraint &
        ) noexcept {
        }

        template <typename Row>
        [[nodiscard]] stellar::StructuralZero AddResidual(
            stellar::equation::OwnConstraint,
            Row &
        ) const noexcept {
            return stellar::structuralZero;
        }

        template <typename Row>
        [[nodiscard]] stellar::StructuralZero AddResidual(
            stellar::equation::HydrostaticBalance,
            Row &
        ) const noexcept {
            return stellar::structuralZero;
        }

        template <
            typename Direction,
            typename Row>
        [[nodiscard]] stellar::StructuralZero AddJacobianAction(
            stellar::Derivative<
                stellar::equation::OwnConstraint,
                stellar::state::SpecificEnthalpy>,
            const Direction &,
            Row &
        ) const noexcept {
            return stellar::zeroDerivative;
        }

        template <
            typename Direction,
            typename Row>
        [[nodiscard]] stellar::StructuralZero AddJacobianAction(
            stellar::Derivative<
                stellar::equation::HydrostaticBalance,
                stellar::state::SpecificEnthalpy>,
            const Direction &,
            Row &
        ) const noexcept {
            return stellar::zeroDerivative;
        }

        template <
            typename Direction,
            typename Row>
        [[nodiscard]] stellar::StructuralZero AddJacobianAction(
            stellar::Derivative<
                stellar::equation::HydrostaticBalance,
                stellar::state::OwnGeneratedCoordinate>,
            const Direction &,
            Row &
        ) const noexcept {
            return stellar::zeroDerivative;
        }
    };

    class MissingHydrostaticResidualProvider final {
    public:
        explicit MissingHydrostaticResidualProvider(
            const stellar_runtime_contract_test::RawNestedProtocolConstraint &
        ) noexcept {
        }

        template <typename Row>
        [[nodiscard]] stellar::StructuralZero AddResidual(
            stellar::equation::OwnConstraint,
            Row &
        ) const noexcept {
            return stellar::structuralZero;
        }

        template <
            typename Direction,
            typename Row>
        [[nodiscard]] stellar::StructuralZero AddJacobianAction(
            stellar::Derivative<
                stellar::equation::OwnConstraint,
                stellar::state::SpecificEnthalpy>,
            const Direction &,
            Row &
        ) const noexcept {
            return stellar::zeroDerivative;
        }

        template <
            typename Direction,
            typename Row>
        [[nodiscard]] stellar::StructuralZero AddJacobianAction(
            stellar::Derivative<
                stellar::equation::HydrostaticBalance,
                stellar::state::SpecificEnthalpy>,
            const Direction &,
            Row &
        ) const noexcept {
            return stellar::zeroDerivative;
        }

        template <
            typename Direction,
            typename Row>
        [[nodiscard]] stellar::StructuralZero AddJacobianAction(
            stellar::Derivative<
                stellar::equation::HydrostaticBalance,
                stellar::state::OwnGeneratedCoordinate>,
            const Direction &,
            Row &
        ) const noexcept {
            return stellar::zeroDerivative;
        }
    };

    class MissingGeneratedControlDerivativeProvider final {
    public:
        explicit MissingGeneratedControlDerivativeProvider(
            const stellar_runtime_contract_test::RawNestedProtocolConstraint &
        ) noexcept {
        }

        template <typename Row>
        [[nodiscard]] stellar::StructuralZero AddResidual(
            stellar::equation::OwnConstraint,
            Row &
        ) const noexcept {
            return stellar::structuralZero;
        }

        template <typename Row>
        [[nodiscard]] stellar::StructuralZero AddResidual(
            stellar::equation::HydrostaticBalance,
            Row &
        ) const noexcept {
            return stellar::structuralZero;
        }

        template <
            typename Direction,
            typename Row>
        [[nodiscard]] stellar::StructuralZero AddJacobianAction(
            stellar::Derivative<
                stellar::equation::OwnConstraint,
                stellar::state::SpecificEnthalpy>,
            const Direction &,
            Row &
        ) const noexcept {
            return stellar::zeroDerivative;
        }

        template <
            typename Direction,
            typename Row>
        [[nodiscard]] stellar::StructuralZero AddJacobianAction(
            stellar::Derivative<
                stellar::equation::HydrostaticBalance,
                stellar::state::SpecificEnthalpy>,
            const Direction &,
            Row &
        ) const noexcept {
            return stellar::zeroDerivative;
        }
    };

    /* The pre-refactor imperative shape can be constructed, but neither callback
     * identifies a compiler-enumerated equation/state pair or returns the token
     * required to prove that the pair was handled. */
    class LegacyBroadEmptyProvider final {
    public:
        explicit LegacyBroadEmptyProvider(const stellar_runtime_contract_test::RawNestedProtocolConstraint &) noexcept {
        }

        template <typename ResidualView> void AddResidual(const ResidualView &) const noexcept {
        }

        template <
            typename DirectionView,
            typename ActionView,
            typename Core>
        void AddJacobianAction(
            const DirectionView &,
            const ActionView &,
            const Core &
        ) const noexcept {
        }
    };

    template <typename Physics, typename Equation>
    concept HasExactProviderResidual = requires(
        const Physics &physics,
        operators::StellarEquilibriumContributionRow<
            stellar_runtime_contract_test::RawNestedProtocolConstraint,
            RawNestedProtocolModel,
            Equation> &row
    ) {
        { physics.AddResidual(Equation{}, row) } -> stellar::ContributionResult;
    };

    template <typename Physics, typename Equation, typename State>
    concept HasExactProviderDerivative = requires(
        const Physics &physics,
        const operators::StellarEquilibriumContributionDirection<
            stellar_runtime_contract_test::RawNestedProtocolConstraint,
            RawNestedProtocolModel,
            State> &direction,
        operators::StellarEquilibriumContributionRow<
            stellar_runtime_contract_test::RawNestedProtocolConstraint,
            RawNestedProtocolModel,
            Equation> &row
    ) {
        {
            physics.AddJacobianAction(stellar::Derivative<Equation, State>{}, direction, row)
        } -> stellar::ContributionResult;
    };

    using AmbiguousRuntimeRegistrationModel           = model::StellarModel<models::SpecificationSet<
        eos::Polytrope,
        surface::Isobaric,
        models::FixedTotalMass,
        stellar_runtime_contract_test::AmbiguousRuntimeRegistrationConstraint>>;

    using UnauthorizedAggregateModel                  = model::StellarModel<models::SpecificationSet<
        eos::Polytrope,
        surface::Isobaric,
        models::FixedTotalMass,
        stellar_runtime_contract_test::UnauthorizedAggregateConstraint>>;

    using AuthorizedAmbiguousRuntimeRegistrationModel = model::StellarModel<models::SpecificationSet<
        stellar_runtime_contract_test::AlternateCoreEquationOfState,
        surface::Isobaric,
        models::FixedTotalMass,
        stellar_runtime_contract_test::AmbiguousRuntimeRegistrationConstraint>>;

    using PhysicalRieszDiscretization = equilibrium::StellarDiscretizationFor<normalization::PhysicalRieszDiagonal<>>;
    using BaseProblem                 = equilibrium::StellarEquilibriumProblem<BaseModel>;
    using BasePhysicalRieszProblem    = equilibrium::StellarEquilibriumProblem<BaseModel, PhysicalRieszDiscretization>;
    using AlternateCoreProblem        = equilibrium::StellarEquilibriumProblem<AlternateCoreModel>;
    using MissingRieszUnnormalizedProblem = equilibrium::StellarEquilibriumProblem<MissingRieszModel>;

    using WrongOwnerModel                 = model::StellarModel<models::SpecificationSet<
        stellar_runtime_contract_test::WrongOwnerEquationOfState,
        surface::Isobaric,
        models::FixedTotalMass>>;

    using IncompleteSurfaceRuntimeModel   = model::StellarModel<models::SpecificationSet<
        eos::Polytrope,
        stellar_runtime_contract_test::IncompleteSurfaceRuntime,
        models::FixedTotalMass>>;

    using CarrierlessManifestForm         = utils::blocks::block_form<
        utils::blocks::type_list<utils::blocks::fixed_total_mass::mass_normalization::value>,
        utils::blocks::type_list<utils::blocks::fixed_total_mass::mass_normalization::residual>>;

    struct UnsupportedCentralDensityEquationOfState final {
        struct Parameters final { };

        using ModelDefinition = models::
            ConstitutiveLaw<UnsupportedCentralDensityEquationOfState, "UnsupportedCentralDensityEquationOfState">;

        explicit UnsupportedCentralDensityEquationOfState(Parameters) noexcept {
        }
    };

    using UnsupportedCentralDensityModel = model::StellarModel<models::SpecificationSet<
        UnsupportedCentralDensityEquationOfState,
        surface::Isobaric,
        models::FixedTotalMass,
        models::FixedCentralDensity>>;

    struct EarlierMultiplier final {
        struct Parameters final { };

        using ModelDefinition = models::FixedIntegralWithMultiplier<
            EarlierMultiplier,
            "AardvarkMultiplier",
            models::DependsOn<utils::blocks::density::mass::value>,
            models::Affects<utils::blocks::enthalpy::specific::residual>>;

        explicit EarlierMultiplier(Parameters) noexcept {
        }
    };

    using EarlierMultiplierValue = utils::blocks::generated_value_block<models::MultiplierFor<EarlierMultiplier>>;
    using EarlierMultiplierModel = model::StellarModel<
        models::SpecificationSet<eos::Polytrope, surface::Isobaric, models::FixedTotalMass, EarlierMultiplier>>;

    struct FullPhysicsStateReader final {
        struct Parameters final { };

        using ModelDefinition = models::FixedIntegralWithPhysicalCoordinate<
            FullPhysicsStateReader,
            "FullPhysicsStateReader",
            models::DependsOn<
                models::stellar::state::Density,
                models::stellar::state::SurfaceShape,
                models::stellar::state::GravityGradient,
                models::stellar::state::GravitationalPotential,
                models::stellar::state::SpecificEnthalpy>,
            models::Affects<models::stellar::equation::HydrostaticBalance>>;

        explicit FullPhysicsStateReader(Parameters) noexcept {
        }
    };

    using FullPhysicsStateReaderModel = model::StellarModel<
        models::SpecificationSet<eos::Polytrope, surface::Isobaric, models::FixedTotalMass, FullPhysicsStateReader>>;

    struct CrossAlpha;
    struct CrossBeta;

    using CrossAlphaValue    = utils::blocks::generated_value_block<models::PhysicalCoordinateFor<CrossAlpha>>;
    using CrossAlphaResidual = utils::blocks::generated_residual_block<models::ResidualFor<CrossAlpha>>;
    using CrossBetaValue     = utils::blocks::generated_value_block<models::PhysicalCoordinateFor<CrossBeta>>;
    using CrossBetaResidual  = utils::blocks::generated_residual_block<models::ResidualFor<CrossBeta>>;

    struct CrossAlphaTerm final {
        using value    = CrossAlphaValue;
        using residual = CrossAlphaResidual;
    };

    struct CrossBetaTerm final {
        using value    = CrossBetaValue;
        using residual = CrossBetaResidual;
    };

    inline constexpr CrossAlphaTerm crossAlphaTerm{};
    inline constexpr CrossBetaTerm crossBetaTerm{};

    struct NoOpJacobianCallback final {
        template <
            typename DirectionView,
            typename ActionView>
        void operator()(
            DirectionView &,
            ActionView &
        ) const noexcept {
        }
    };

    struct OneArgumentJacobianCallback final {
        template <typename DirectionView> void operator()(DirectionView &) const noexcept {
        }
    };

    struct NonVoidJacobianCallback final {
        template <
            typename DirectionView,
            typename ActionView>
        [[nodiscard]] int operator()(
            DirectionView &,
            ActionView &
        ) const noexcept {
            return 0;
        }
    };

    template <
        typename JacobianView,
        typename ResidualTerm,
        typename ValueTerm,
        typename Callback = NoOpJacobianCallback>
    concept CanBindDeclaredJacobianCallback = requires(
        const JacobianView &jacobian,
        const ResidualTerm &residual,
        const ValueTerm &value,
        Callback callback
    ) { jacobian.add(residual, value, std::move(callback)); };

    template <typename JacobianView, typename ResidualTerm, typename ValueTerm>
    concept CanAddRawJacobianContribution =
        requires(const JacobianView &jacobian, const ResidualTerm &residual, const ValueTerm &value) {
            jacobian.add(residual, value, 1.0);
        };

    template <typename JacobianView, typename ResidualTerm, typename ValueTerm>
    concept CanAddRawJacobianEntry =
        requires(const JacobianView &jacobian, const ResidualTerm &residual, const ValueTerm &value) {
            jacobian.addEntry(residual, value, 0, 1.0);
        };

    /*
     * Alpha is canonicalized before Beta, yet both of Alpha's edges name a
     * block contributed by Beta. A sequential compiler loses Alpha's affected
     * edge because Beta's residual row does not exist yet.
     */
    struct CrossAlpha final {
        struct Parameters final { };

        using ModelDefinition = models::FixedIntegralWithPhysicalCoordinate<
            CrossAlpha,
            "CompilerCrossAlpha",
            models::DependsOn<CrossBetaValue>,
            models::Affects<CrossBetaResidual>>;

        explicit CrossAlpha(Parameters) noexcept {
        }
    };

    struct CrossBeta final {
        struct Parameters final { };

        using ModelDefinition = models::FixedIntegralWithPhysicalCoordinate<
            CrossBeta,
            "CompilerCrossBeta",
            models::DependsOn<utils::blocks::density::mass::value>,
            models::Affects<utils::blocks::surface_deformation::shape_equilibrium::residual>>;

        explicit CrossBeta(Parameters) noexcept {
        }
    };

    using CrossModel = model::StellarModel<
        models::SpecificationSet<eos::Polytrope, surface::Isobaric, models::FixedTotalMass, CrossAlpha, CrossBeta>>;

    using PermutedCrossModel = model::StellarModel<
        models::SpecificationSet<CrossBeta, models::FixedTotalMass, surface::Isobaric, CrossAlpha, eos::Polytrope>>;

    struct MalformedDeclaration final {
        struct Parameters final { };

        using ModelDefinition = models::FixedIntegralWithPhysicalCoordinate<
            MalformedDeclaration,
            "MalformedCompilerDeclaration",
            models::DependsOn<int>,
            models::Affects<utils::blocks::enthalpy::specific::residual>>;

        explicit MalformedDeclaration(Parameters) noexcept {
        }
    };

    using MalformedModel = model::StellarModel<
        models::SpecificationSet<eos::Polytrope, surface::Isobaric, models::FixedTotalMass, MalformedDeclaration>>;

    struct UnmappedStellarState final { };

    struct UnmappedPhysicsDependency final {
        struct Parameters final { };

        using ModelDefinition = models::FixedIntegralWithPhysicalCoordinate<
            UnmappedPhysicsDependency,
            "UnmappedPhysicsDependency",
            models::DependsOn<UnmappedStellarState>,
            models::Affects<models::stellar::equation::HydrostaticBalance>>;

        explicit UnmappedPhysicsDependency(Parameters) noexcept {
        }
    };

    using UnmappedPhysicsModel = model::StellarModel<
        models::SpecificationSet<eos::Polytrope, surface::Isobaric, models::FixedTotalMass, UnmappedPhysicsDependency>>;

    struct UnmappedStellarEquation final { };

    struct UnmappedPhysicsEffect final {
        struct Parameters final { };

        using ModelDefinition = models::FixedIntegralWithPhysicalCoordinate<
            UnmappedPhysicsEffect,
            "UnmappedPhysicsEffect",
            models::DependsOn<models::stellar::state::Density>,
            models::Affects<UnmappedStellarEquation>>;

        explicit UnmappedPhysicsEffect(Parameters) noexcept {
        }
    };

    using UnmappedPhysicsEffectModel = model::StellarModel<
        models::SpecificationSet<eos::Polytrope, surface::Isobaric, models::FixedTotalMass, UnmappedPhysicsEffect>>;

    struct ForeignValueBlock final : utils::blocks::value_block_base { };

    struct OrphanEndpoint final {
        struct Parameters final { };

        using ModelDefinition = models::FixedIntegralWithPhysicalCoordinate<
            OrphanEndpoint,
            "OrphanCompilerEndpoint",
            models::DependsOn<ForeignValueBlock>,
            models::Affects<utils::blocks::enthalpy::specific::residual>>;

        explicit OrphanEndpoint(Parameters) noexcept {
        }
    };

    using OrphanEndpointModel = model::StellarModel<models::SpecificationSet<eos::Polytrope, OrphanEndpoint>>;

    template <typename Candidate>
    concept HasCompiledStellarEquilibriumSystem =
        requires { typename operators::CompiledStellarEquilibriumSystem<Candidate>; };

    template <typename Candidate>
    concept HasPreparedVariadicStellarEquilibriumOperator =
        requires { typename operators::PreparedVariadicStellarEquilibriumOperator<Candidate>; };

    template <typename Problem>
    concept HasNormalizedStellarEquilibriumOperator =
        requires { typename normalization::NormalizedStellarEquilibriumOperator<Problem>; };

    template <typename Problem>
    concept CanMakeNormalizedStellarEquilibriumOperator =
        requires(Problem &problem) { normalization::makeNormalizedStellarEquilibriumOperator(problem); };

    template <typename Problem>
    concept CanMakeDefaultStellarPreconditioner =
        requires(const Problem &problem) { preconditioning::makePreconditioner(problem); };

    template <typename Model, typename Discretization>
    concept HasStellarEquilibriumProblem =
        requires { typename equilibrium::StellarEquilibriumProblem<Model, Discretization>; };

    template <typename Model, typename Discretization>
    concept CanDiscretizeStellarModel = requires(Model &&model, Discretization discretization) {
        equilibrium::discretize(std::move(model), std::move(discretization));
    };

    template <typename View, typename Term>
    concept CanAccessContributionBlock = requires(const View &view, const Term &term) { view.block(term); };

    template <typename View, typename Term>
    concept CanAddContributionBlock = requires(const View &view, const Term &term) { view.add(term, 0.0); };

    template <typename View, typename Term>
    concept CanAddContributionVectorAndEntry =
        requires(const View &view, const Term &term, const mfem::Vector &contribution) {
            view.add(term, contribution);
            view.addEntry(term, 0, 0.0);
        };

    template <typename View>
    concept HasPhysicsDensity = requires(const View &view) { view.density(); };

    template <typename View>
    concept HasPhysicsSurfaceShape = requires(const View &view) { view.surfaceShape(); };

    template <typename View>
    concept HasPhysicsGravityGradient = requires(const View &view) { view.gravityGradient(); };

    template <typename View>
    concept HasPhysicsGravitationalPotential = requires(const View &view) { view.gravitationalPotential(); };

    template <typename View>
    concept HasPhysicsSpecificEnthalpy = requires(const View &view) { view.specificEnthalpy(); };

    template <typename View>
    concept HasPhysicsGeneratedCoordinate = requires(const View &view) { view.generatedCoordinate(); };

    template <typename View>
    concept ExposesUnrestrictedRootVector = requires(const View &view) { view.vector(); };

    template <
        typename ExpectedSourceTerm,
        typename OtherSourceTerm,
        typename ExpectedResidualTerm,
        typename OtherResidualTerm,
        bool NamesOwnGeneratedCoordinate>
    struct ExactPairAuditCallback final {
        template <
            typename DirectionView,
            typename ActionView>
            requires CanAccessContributionBlock<
                         DirectionView,
                         ExpectedSourceTerm> &&
                     (!CanAccessContributionBlock<
                         DirectionView,
                         OtherSourceTerm>) &&
                     (HasPhysicsGeneratedCoordinate<DirectionView> == NamesOwnGeneratedCoordinate) &&
                     (!HasPhysicsDensity<DirectionView>) && (!HasPhysicsSpecificEnthalpy<DirectionView>) &&
                     CanAddContributionBlock<
                         ActionView,
                         ExpectedResidualTerm> &&
                     CanAddContributionVectorAndEntry<
                         ActionView,
                         ExpectedResidualTerm> &&
                     (!CanAddContributionBlock<
                         ActionView,
                         OtherResidualTerm>) &&
                     (!ExposesUnrestrictedRootVector<DirectionView>) && (!ExposesUnrestrictedRootVector<ActionView>)
        void operator()(
            DirectionView &,
            ActionView &
        ) const noexcept {
        }
    };

    struct RequiresCrossProductDirectionCallback final {
        template <
            typename DirectionView,
            typename ActionView>
            requires CanAccessContributionBlock<
                         DirectionView,
                         CrossAlphaTerm> &&
                     CanAccessContributionBlock<
                         DirectionView,
                         CrossBetaTerm>
        void operator()(
            DirectionView &,
            ActionView &
        ) const noexcept {
        }
    };

    struct RequiresCrossProductActionCallback final {
        template <
            typename DirectionView,
            typename ActionView>
            requires CanAddContributionBlock<
                         ActionView,
                         CrossAlphaTerm> &&
                     CanAddContributionBlock<
                         ActionView,
                         CrossBetaTerm>
        void operator()(
            DirectionView &,
            ActionView &
        ) const noexcept {
        }
    };
} // namespace

TEST_CASE(
    "Two-Pass Stellar Compiler Preserves Established Physical Forms",
    "[stellar-equilibrium][compiler][type-contract]"
) {
    using namespace mean_field;

    STATIC_CHECK(operators::StellarEquilibriumSystemCompilable<BaseModel>);
    STATIC_CHECK(BaseModel::hasCompleteEquilibriumDeclaration);
    STATIC_CHECK(
        operators::CompiledStellarEquilibriumSystem<BaseModel>::compilationClass ==
        models::EquilibriumSystemCompilation::complete_equilibrium_system
    );
    STATIC_CHECK(operators::hasStellarEquilibriumCoreRuntime<BaseModel>);
    STATIC_CHECK(operators::hasCompleteStellarEquilibriumRuntime<BaseModel>);
    STATIC_CHECK(equilibrium::hasStellarEquilibriumSurfaceCompilation<BaseModel>);
    STATIC_CHECK(operators::StellarEquilibriumSystemCompilable<CentralDensityModel>);
    STATIC_CHECK(operators::StellarEquilibriumSystemCompilable<AngularMomentumModel>);
    STATIC_CHECK(operators::StellarEquilibriumSystemCompilable<AngularCentralDensityModel>);
    STATIC_CHECK((std::same_as<
                  operators::CompiledStellarEquilibriumForm<BaseModel>,
                  utils::blocks::surface_deformed_stellar_equilibrium_form>));
    STATIC_CHECK((std::same_as<
                  operators::CompiledStellarEquilibriumJacobianForm<BaseModel>,
                  utils::blocks::surface_deformed_stellar_equilibrium_jacobian_form>));
    STATIC_CHECK((std::same_as<
                  operators::CompiledStellarEquilibriumForm<CentralDensityModel>,
                  utils::blocks::central_density_bordered_stellar_equilibrium_form>));
    STATIC_CHECK((std::same_as<
                  operators::CompiledStellarEquilibriumJacobianForm<CentralDensityModel>,
                  utils::blocks::central_density_bordered_stellar_equilibrium_jacobian_form>));
    STATIC_CHECK((
        std::same_as<operators::CompiledStellarEquilibriumForm<AngularMomentumModel>, ExpectedAngularMomentumForm>
    ));
    STATIC_CHECK((
        std::same_as<
            operators::CompiledStellarEquilibriumJacobianForm<AngularMomentumModel>, ExpectedAngularMomentumJacobian>
    ));
    STATIC_CHECK((
        std::same_as<
            operators::CompiledStellarEquilibriumForm<AngularCentralDensityModel>, ExpectedAngularCentralDensityForm>
    ));
    STATIC_CHECK((std::same_as<
                  operators::CompiledStellarEquilibriumJacobianForm<AngularCentralDensityModel>,
                  ExpectedAngularCentralDensityJacobian>));
}

TEST_CASE(
    "Runtime Contributions See Only Their Declared Physics Blocks",
    "[stellar-equilibrium][runtime][sparsity][type-contract]"
) {
    using namespace mean_field;
    using AngularState =
        operators::StellarEquilibriumContributionStateView<models::FixedAngularMomentum, AngularMomentumModel>;
    using AngularResidual =
        operators::StellarEquilibriumContributionResidualView<models::FixedAngularMomentum, AngularMomentumModel>;
    using CentralState =
        operators::StellarEquilibriumContributionStateView<models::FixedCentralDensity, CentralDensityModel>;
    using CentralResidual =
        operators::StellarEquilibriumContributionResidualView<models::FixedCentralDensity, CentralDensityModel>;
    using FullPhysicsState =
        operators::StellarEquilibriumContributionStateView<FullPhysicsStateReader, FullPhysicsStateReaderModel>;

    STATIC_CHECK(CanAccessContributionBlock<AngularState, decltype(utils::blocks::density_field.mass_term)>);
    STATIC_CHECK(
        CanAccessContributionBlock<AngularState, decltype(utils::blocks::surface_deformation_field.parameters_term)>
    );
    STATIC_CHECK(
        CanAccessContributionBlock<
            AngularState, decltype(utils::blocks::fixed_angular_momentum_constraint.angular_velocity_term)>
    );
    STATIC_CHECK_FALSE(CanAccessContributionBlock<AngularState, decltype(utils::blocks::gravity_field.poisson_term)>);
    STATIC_CHECK(HasPhysicsDensity<AngularState>);
    STATIC_CHECK(HasPhysicsSurfaceShape<AngularState>);
    STATIC_CHECK(HasPhysicsGeneratedCoordinate<AngularState>);
    STATIC_CHECK_FALSE(HasPhysicsGravityGradient<AngularState>);
    STATIC_CHECK_FALSE(HasPhysicsGravitationalPotential<AngularState>);
    STATIC_CHECK_FALSE(HasPhysicsSpecificEnthalpy<AngularState>);

    STATIC_CHECK(
        CanAddContributionBlock<
            AngularResidual, decltype(utils::blocks::fixed_angular_momentum_constraint.angular_velocity_term)>
    );
    STATIC_CHECK(
        CanAddContributionBlock<
            AngularResidual, decltype(utils::blocks::surface_deformation_field.shape_equilibrium_term)>
    );
    STATIC_CHECK(CanAddContributionBlock<AngularResidual, decltype(utils::blocks::enthalpy_field.specific_term)>);
    STATIC_CHECK_FALSE(CanAddContributionBlock<AngularResidual, decltype(utils::blocks::density_field.mass_term)>);

    STATIC_CHECK(CanAccessContributionBlock<CentralState, decltype(utils::blocks::enthalpy_field.specific_term)>);
    STATIC_CHECK(
        CanAccessContributionBlock<
            CentralState, decltype(utils::blocks::fixed_central_density_phase.central_value_term)>
    );
    STATIC_CHECK_FALSE(CanAccessContributionBlock<CentralState, decltype(utils::blocks::density_field.mass_term)>);
    STATIC_CHECK(HasPhysicsSpecificEnthalpy<CentralState>);
    STATIC_CHECK(HasPhysicsGeneratedCoordinate<CentralState>);
    STATIC_CHECK_FALSE(HasPhysicsDensity<CentralState>);
    STATIC_CHECK_FALSE(HasPhysicsSurfaceShape<CentralState>);

    // The astronomer-facing names span the complete current barotropic core
    // and the specification's inferred scalar without exposing backend block
    // types. Each accessor remains absent unless its dependency was declared.
    STATIC_CHECK(HasPhysicsDensity<FullPhysicsState>);
    STATIC_CHECK(HasPhysicsSurfaceShape<FullPhysicsState>);
    STATIC_CHECK(HasPhysicsGravityGradient<FullPhysicsState>);
    STATIC_CHECK(HasPhysicsGravitationalPotential<FullPhysicsState>);
    STATIC_CHECK(HasPhysicsSpecificEnthalpy<FullPhysicsState>);
    STATIC_CHECK(HasPhysicsGeneratedCoordinate<FullPhysicsState>);
    STATIC_CHECK(CanAddContributionBlock<CentralResidual, decltype(utils::blocks::enthalpy_field.specific_term)>);
    STATIC_CHECK(
        CanAddContributionBlock<
            CentralResidual, decltype(utils::blocks::fixed_central_density_phase.central_value_term)>
    );

    // Residual access is additive-only: declared rows are writable through add,
    // but no specification can obtain a mutable block and overwrite an earlier
    // contribution.  There is also no escape hatch to the full root vector.
    STATIC_CHECK_FALSE(
        CanAccessContributionBlock<AngularResidual, decltype(utils::blocks::enthalpy_field.specific_term)>
    );
    STATIC_CHECK_FALSE(
        CanAccessContributionBlock<CentralResidual, decltype(utils::blocks::enthalpy_field.specific_term)>
    );
    STATIC_CHECK_FALSE(ExposesUnrestrictedRootVector<AngularState>);
    STATIC_CHECK_FALSE(ExposesUnrestrictedRootVector<AngularResidual>);
    STATIC_CHECK_FALSE(ExposesUnrestrictedRootVector<CentralState>);
    STATIC_CHECK_FALSE(ExposesUnrestrictedRootVector<CentralResidual>);
}

TEST_CASE(
    "Built-In Physics Declarations Are The Compiler's Single Source",
    "[stellar-equilibrium][compiler][metadata][physics-api]"
) {
    using namespace mean_field;
    using EmptyBlocks          = utils::blocks::type_list<>;
    using PolytropeCompilation = operators::StellarEquilibriumSpecificationCompilation<eos::Polytrope>;
    using IsobaricCompilation  = operators::StellarEquilibriumSpecificationCompilation<surface::Isobaric>;
    using MassContribution     = models::SpecificationContribution<models::FixedTotalMass>;
    using AngularContribution  = models::SpecificationContribution<models::FixedAngularMomentum>;
    using CentralContribution  = models::SpecificationContribution<models::FixedCentralDensity>;

    STATIC_CHECK((std::same_as<
                  typename MassContribution::DependsOn,
                  models::DependsOn<models::stellar::state::Density, models::stellar::state::SurfaceShape>>));
    STATIC_CHECK((
        std::same_as<typename MassContribution::Affects, models::Affects<models::stellar::equation::HydrostaticBalance>>
    ));
    STATIC_CHECK((std::same_as<
                  typename AngularContribution::DependsOn,
                  models::DependsOn<
                      models::stellar::state::Density, models::stellar::state::SurfaceShape,
                      models::stellar::state::OwnGeneratedCoordinate>>));
    STATIC_CHECK((std::same_as<
                  typename AngularContribution::Affects,
                  models::Affects<
                      models::stellar::equation::SurfaceShapeBalance, models::stellar::equation::HydrostaticBalance>>));
    STATIC_CHECK((
        std::same_as<
            typename CentralContribution::DependsOn, models::DependsOn<models::stellar::state::SpecificEnthalpy>>
    ));
    STATIC_CHECK((
        std::same_as<
            typename CentralContribution::Affects, models::Affects<models::stellar::equation::HydrostaticBalance>>
    ));

    using MassCompilation    = operators::StellarEquilibriumSpecificationCompilation<models::FixedTotalMass>;
    using AngularCompilation = operators::StellarEquilibriumSpecificationCompilation<models::FixedAngularMomentum>;
    using CentralCompilation = operators::StellarEquilibriumSpecificationCompilation<models::FixedCentralDensity>;

    STATIC_CHECK(operators::stellarEquilibriumSpecificationCompilationComplete<eos::Polytrope>);
    STATIC_CHECK(operators::stellarEquilibriumSpecificationCompilationComplete<surface::Isobaric>);
    STATIC_CHECK((std::same_as<typename PolytropeCompilation::GeneratedValueBlocks, EmptyBlocks>));
    STATIC_CHECK((std::same_as<typename PolytropeCompilation::GeneratedResidualBlocks, EmptyBlocks>));
    STATIC_CHECK((std::same_as<typename IsobaricCompilation::GeneratedValueBlocks, EmptyBlocks>));
    STATIC_CHECK((std::same_as<typename IsobaricCompilation::GeneratedResidualBlocks, EmptyBlocks>));
    STATIC_CHECK((
        std::same_as<
            typename MassCompilation::DependsOnValueBlocks, utils::blocks::type_list<DensityValue, SurfaceValue>>
    ));
    STATIC_CHECK((
        std::same_as<typename MassCompilation::AffectedResidualBlocks, utils::blocks::type_list<EnthalpyResidual>>
    ));
    STATIC_CHECK((std::same_as<
                  typename AngularCompilation::DependsOnValueBlocks,
                  utils::blocks::type_list<DensityValue, SurfaceValue, AngularVelocityValue>>));
    STATIC_CHECK((std::same_as<
                  typename AngularCompilation::AffectedResidualBlocks,
                  utils::blocks::type_list<SurfaceResidual, EnthalpyResidual>>));
    STATIC_CHECK((
        std::same_as<typename CentralCompilation::DependsOnValueBlocks, utils::blocks::type_list<EnthalpyValue>>
    ));
    STATIC_CHECK((
        std::same_as<typename CentralCompilation::AffectedResidualBlocks, utils::blocks::type_list<EnthalpyResidual>>
    ));

    const auto descriptors = AngularCentralDensityModel::runtimeSpecificationDescriptors();
    REQUIRE(descriptors.size() == 5);
    CHECK(descriptors[2].specification.name == "FixedTotalMass");
    CHECK(descriptors[3].specification.name == "FixedAngularMomentum");
    CHECK(descriptors[4].specification.name == "FixedCentralDensity");
    CHECK(descriptors[2].hasDeclarativeDefinition);
    CHECK(descriptors[3].hasDeclarativeDefinition);
    CHECK(descriptors[4].hasDeclarativeDefinition);
}

TEST_CASE(
    "Fixed Total Mass Exposes Its Generated Blocks And Incident Edges",
    "[stellar-equilibrium][compiler][metadata]"
) {
    using namespace mean_field;
    using Compilation  = operators::StellarEquilibriumSpecificationCompilation<models::FixedTotalMass>;
    using MassValue    = utils::blocks::fixed_total_mass::mass_normalization::value;
    using MassResidual = utils::blocks::fixed_total_mass::mass_normalization::residual;

    STATIC_CHECK(operators::stellarEquilibriumSpecificationCompilationComplete<models::FixedTotalMass>);
    STATIC_CHECK((std::same_as<typename Compilation::GeneratedValueBlocks, utils::blocks::type_list<MassValue>>));
    STATIC_CHECK((std::same_as<typename Compilation::GeneratedCorrectionBlocks, utils::blocks::type_list<MassValue>>));
    STATIC_CHECK((std::same_as<typename Compilation::GeneratedResidualBlocks, utils::blocks::type_list<MassResidual>>));
    STATIC_CHECK(
        utils::blocks::contains_type_v<
            operators::EquilibriumJacobianCoupling<MassResidual, utils::blocks::density::mass::value>,
            typename Compilation::IncidentJacobianCouplings>
    );
    STATIC_CHECK(
        utils::blocks::contains_type_v<
            operators::EquilibriumJacobianCoupling<utils::blocks::enthalpy::specific::residual, MassValue>,
            typename Compilation::IncidentJacobianCouplings>
    );
}

TEST_CASE(
    "Core Coordinates Are Identified By Type Rather Than Pack Position",
    "[stellar-equilibrium][compiler][ordering]"
) {
    using namespace mean_field;
    using Form      = operators::CompiledStellarEquilibriumForm<EarlierMultiplierModel>;
    using MassValue = utils::blocks::fixed_total_mass::mass_normalization::value;

    STATIC_CHECK(operators::StellarEquilibriumSystemCompilable<EarlierMultiplierModel>);
    STATIC_CHECK(utils::blocks::type_index_v<EarlierMultiplierValue, typename Form::value_blocks> == 5);
    STATIC_CHECK(utils::blocks::type_index_v<MassValue, typename Form::value_blocks> == 6);
    STATIC_CHECK(
        utils::blocks::has_jacobian_coupling_v<
            utils::blocks::enthalpy::specific::residual, EarlierMultiplierValue,
            operators::CompiledStellarEquilibriumJacobianForm<EarlierMultiplierModel>>
    );
}

TEST_CASE(
    "Two-Pass Compiler Resolves Couplings Across Independently Declared "
    "Constraints",
    "[stellar-equilibrium][compiler][variadic][order-independence]"
) {
    using namespace mean_field;
    using System   = operators::CompiledStellarEquilibriumSystem<CrossModel>;
    using Form     = typename System::FormType;
    using Jacobian = typename System::JacobianType;

    STATIC_CHECK(models::ModelSpecification<CrossAlpha>);
    STATIC_CHECK(models::ModelSpecification<CrossBeta>);
    STATIC_CHECK((std::same_as<CrossModel, PermutedCrossModel>));
    STATIC_CHECK(operators::stellarEquilibriumSpecificationCompilationComplete<CrossAlpha>);
    STATIC_CHECK(operators::stellarEquilibriumSpecificationCompilationComplete<CrossBeta>);
    STATIC_CHECK(operators::StellarEquilibriumSystemCompilable<CrossModel>);
    STATIC_CHECK(Form::value_block_count == 8);
    STATIC_CHECK(Form::residual_block_count == 8);
    STATIC_CHECK(utils::blocks::valid_jacobian_form<Form, Jacobian>);

    // Both endpoints are introduced by different declarations. In particular,
    // R_B does not exist when a one-pass compiler visits Alpha.
    STATIC_CHECK(utils::blocks::has_jacobian_coupling_v<CrossBetaResidual, CrossAlphaValue, Jacobian>);
    STATIC_CHECK(utils::blocks::has_jacobian_coupling_v<CrossAlphaResidual, CrossBetaValue, Jacobian>);
    STATIC_CHECK(
        utils::blocks::has_jacobian_coupling_v<CrossBetaResidual, utils::blocks::density::mass::value, Jacobian>
    );
    STATIC_CHECK(
        utils::blocks::has_jacobian_coupling_v<
            utils::blocks::surface_deformation::shape_equilibrium::residual, CrossBetaValue, Jacobian>
    );

    // Changes are conservatively state dependent on every declared Read. This
    // is the Hessian-like block required by nonlinear constrained systems.
    STATIC_CHECK(utils::blocks::has_jacobian_coupling_v<CrossBetaResidual, CrossBetaValue, Jacobian>);

    STATIC_CHECK(
        utils::blocks::contains_type_v<
            operators::EquilibriumJacobianCoupling<CrossBetaResidual, CrossAlphaValue>,
            typename System::ContributionJacobianCouplings>
    );
    STATIC_CHECK((std::same_as<
                  typename System::GeneratedCorrectionBlocks,
                  utils::blocks::type_list<
                      utils::blocks::fixed_total_mass::mass_normalization::value, CrossAlphaValue, CrossBetaValue>>));

    using CrossAlphaJacobian = operators::StellarEquilibriumContributionJacobianView<CrossAlpha, CrossModel>;
    using AlphaResidualFromBetaValue =
        ExactPairAuditCallback<CrossBetaTerm, CrossAlphaTerm, CrossAlphaTerm, CrossBetaTerm, false>;
    using BetaResidualFromAlphaValue =
        ExactPairAuditCallback<CrossAlphaTerm, CrossBetaTerm, CrossBetaTerm, CrossAlphaTerm, true>;
    using BetaResidualFromBetaValue =
        ExactPairAuditCallback<CrossBetaTerm, CrossAlphaTerm, CrossBetaTerm, CrossAlphaTerm, false>;

    STATIC_CHECK(
        CanBindDeclaredJacobianCallback<CrossAlphaJacobian, CrossAlphaTerm, CrossBetaTerm, AlphaResidualFromBetaValue>
    );
    STATIC_CHECK(
        CanBindDeclaredJacobianCallback<CrossAlphaJacobian, CrossBetaTerm, CrossAlphaTerm, BetaResidualFromAlphaValue>
    );
    STATIC_CHECK(
        CanBindDeclaredJacobianCallback<CrossAlphaJacobian, CrossBetaTerm, CrossBetaTerm, BetaResidualFromBetaValue>
    );

    // Alpha's residual does not read Alpha's coordinate. Although that row and
    // column are independently present in other callbacks, their undeclared
    // diagonal cannot bind a callback. Raw scalar writes and malformed callback
    // protocols are rejected too: all numeric accumulation happens through the
    // one-row action supplied to a valid callback.
    STATIC_CHECK_FALSE(CanBindDeclaredJacobianCallback<CrossAlphaJacobian, CrossAlphaTerm, CrossAlphaTerm>);
    STATIC_CHECK_FALSE(CanAddRawJacobianContribution<CrossAlphaJacobian, CrossAlphaTerm, CrossBetaTerm>);
    STATIC_CHECK_FALSE(CanAddRawJacobianEntry<CrossAlphaJacobian, CrossAlphaTerm, CrossBetaTerm>);
    STATIC_CHECK_FALSE(
        CanBindDeclaredJacobianCallback<CrossAlphaJacobian, CrossAlphaTerm, CrossBetaTerm, OneArgumentJacobianCallback>
    );
    STATIC_CHECK_FALSE(
        CanBindDeclaredJacobianCallback<CrossAlphaJacobian, CrossAlphaTerm, CrossBetaTerm, NonVoidJacobianCallback>
    );
    STATIC_CHECK_FALSE(
        CanBindDeclaredJacobianCallback<
            CrossAlphaJacobian, CrossAlphaTerm, CrossBetaTerm, RequiresCrossProductDirectionCallback>
    );
    STATIC_CHECK_FALSE(
        CanBindDeclaredJacobianCallback<
            CrossAlphaJacobian, CrossAlphaTerm, CrossBetaTerm, RequiresCrossProductActionCallback>
    );
    STATIC_CHECK_FALSE(CanBindDeclaredJacobianCallback<CrossAlphaJacobian, int, CrossBetaTerm>);
}

TEST_CASE(
    "Exact Physics Providers Must Cover Every Compiler-Inferred Pair",
    "[stellar-equilibrium][compiler][physics-provider][contracts]"
) {
    using Specification = stellar_runtime_contract_test::RawNestedProtocolConstraint;
    using Model         = RawNestedProtocolModel;
    using Topology      = operators::StellarEquilibriumContributionTopology<Specification, Model>;

    STATIC_CHECK(Topology::ResidualEquations::size == 2);
    STATIC_CHECK(Topology::Derivatives::size == 3);

    STATIC_CHECK((std::constructible_from<CompleteExplicitZeroProvider, const Specification &>));
    STATIC_CHECK((HasExactProviderResidual<CompleteExplicitZeroProvider, stellar::equation::OwnConstraint>));
    STATIC_CHECK((HasExactProviderResidual<CompleteExplicitZeroProvider, stellar::equation::HydrostaticBalance>));
    STATIC_CHECK((HasExactProviderDerivative<
                  CompleteExplicitZeroProvider, stellar::equation::OwnConstraint, stellar::state::SpecificEnthalpy>));
    STATIC_CHECK((
        HasExactProviderDerivative<
            CompleteExplicitZeroProvider, stellar::equation::HydrostaticBalance, stellar::state::SpecificEnthalpy>
    ));
    STATIC_CHECK((
        HasExactProviderDerivative<
            CompleteExplicitZeroProvider, stellar::equation::HydrostaticBalance, stellar::state::OwnGeneratedCoordinate>
    ));
    STATIC_CHECK((
        operators::CompleteStellarEquilibriumPhysicsProvider<CompleteExplicitZeroProvider, Specification, Model>
    ));

    // This provider has the valid constructor and all three inferred
    // derivatives.  Omitting only the changed physical residual rejects it.
    STATIC_CHECK((std::constructible_from<MissingHydrostaticResidualProvider, const Specification &>));
    STATIC_CHECK((HasExactProviderResidual<MissingHydrostaticResidualProvider, stellar::equation::OwnConstraint>));
    STATIC_CHECK_FALSE((
        HasExactProviderResidual<MissingHydrostaticResidualProvider, stellar::equation::HydrostaticBalance>
    ));
    STATIC_CHECK((
        HasExactProviderDerivative<
            MissingHydrostaticResidualProvider, stellar::equation::OwnConstraint, stellar::state::SpecificEnthalpy>
    ));
    STATIC_CHECK((
        HasExactProviderDerivative<
            MissingHydrostaticResidualProvider, stellar::equation::HydrostaticBalance, stellar::state::SpecificEnthalpy>
    ));
    STATIC_CHECK((HasExactProviderDerivative<
                  MissingHydrostaticResidualProvider, stellar::equation::HydrostaticBalance,
                  stellar::state::OwnGeneratedCoordinate>));
    STATIC_CHECK_FALSE((
        operators::CompleteStellarEquilibriumPhysicsProvider<MissingHydrostaticResidualProvider, Specification, Model>
    ));

    // This provider has the valid constructor and both inferred residuals.
    // Omitting only d(hydrostatic)/d(owned coordinate) rejects it.
    STATIC_CHECK((std::constructible_from<MissingGeneratedControlDerivativeProvider, const Specification &>));
    STATIC_CHECK((
        HasExactProviderResidual<MissingGeneratedControlDerivativeProvider, stellar::equation::OwnConstraint>
    ));
    STATIC_CHECK((
        HasExactProviderResidual<MissingGeneratedControlDerivativeProvider, stellar::equation::HydrostaticBalance>
    ));
    STATIC_CHECK((HasExactProviderDerivative<
                  MissingGeneratedControlDerivativeProvider, stellar::equation::OwnConstraint,
                  stellar::state::SpecificEnthalpy>));
    STATIC_CHECK((HasExactProviderDerivative<
                  MissingGeneratedControlDerivativeProvider, stellar::equation::HydrostaticBalance,
                  stellar::state::SpecificEnthalpy>));
    STATIC_CHECK_FALSE((HasExactProviderDerivative<
                        MissingGeneratedControlDerivativeProvider, stellar::equation::HydrostaticBalance,
                        stellar::state::OwnGeneratedCoordinate>));
    STATIC_CHECK_FALSE((operators::CompleteStellarEquilibriumPhysicsProvider<
                        MissingGeneratedControlDerivativeProvider, Specification, Model>));

    // Construction alone does not grandfather in the former broad/imperative
    // callbacks.  They provide neither an equation-tagged residual result nor
    // a derivative-tagged Jacobian result.
    STATIC_CHECK((std::constructible_from<LegacyBroadEmptyProvider, const Specification &>));
    STATIC_CHECK_FALSE((HasExactProviderResidual<LegacyBroadEmptyProvider, stellar::equation::OwnConstraint>));
    STATIC_CHECK_FALSE((HasExactProviderDerivative<
                        LegacyBroadEmptyProvider, stellar::equation::OwnConstraint, stellar::state::SpecificEnthalpy>));
    STATIC_CHECK_FALSE((
        operators::CompleteStellarEquilibriumPhysicsProvider<LegacyBroadEmptyProvider, Specification, Model>
    ));
}

TEST_CASE(
    "Compiler Capability Queries Reject Invalid Declarations Without "
    "Hard Errors",
    "[stellar-equilibrium][compiler][sfinae]"
) {
    using namespace mean_field;

    STATIC_CHECK_FALSE(operators::stellarEquilibriumSpecificationCompilationComplete<int>);
    STATIC_CHECK_FALSE(operators::stellarEquilibriumSpecificationCompilationComplete<MalformedDeclaration>);
    STATIC_CHECK_FALSE(operators::StellarEquilibriumSystemCompilable<MalformedModel>);
    STATIC_CHECK_FALSE(HasCompiledStellarEquilibriumSystem<MalformedModel>);
    STATIC_CHECK(models::ModelSpecification<UnmappedPhysicsDependency>);
    // A valid declaration is not a claim that the numerical compiler knows how
    // to map every name it contains.
    STATIC_CHECK(UnmappedPhysicsModel::hasCompleteEquilibriumDeclaration);
    STATIC_CHECK_FALSE(operators::stellarEquilibriumSpecificationCompilationComplete<UnmappedPhysicsDependency>);
    STATIC_CHECK_FALSE(operators::StellarEquilibriumSystemCompilable<UnmappedPhysicsModel>);
    STATIC_CHECK_FALSE(HasCompiledStellarEquilibriumSystem<UnmappedPhysicsModel>);
    STATIC_CHECK(models::ModelSpecification<UnmappedPhysicsEffect>);
    STATIC_CHECK_FALSE(operators::stellarEquilibriumSpecificationCompilationComplete<UnmappedPhysicsEffect>);
    STATIC_CHECK_FALSE(operators::StellarEquilibriumSystemCompilable<UnmappedPhysicsEffectModel>);
    STATIC_CHECK_FALSE(HasCompiledStellarEquilibriumSystem<UnmappedPhysicsEffectModel>);
    STATIC_CHECK_FALSE(operators::StellarEquilibriumSystemCompilable<int>);
    STATIC_CHECK_FALSE(HasCompiledStellarEquilibriumSystem<int>);
    STATIC_CHECK(
        operators::StellarEquilibriumBackendSpecificationList<models::ModelTypeList<eos::Polytrope, surface::Isobaric>>
    );
    STATIC_CHECK(operators::StellarEquilibriumBackendSpecificationList<models::ModelTypeList<>>);
    STATIC_CHECK_FALSE(operators::StellarEquilibriumBackendSpecificationList<models::ModelTypeList<int>>);
    STATIC_CHECK_FALSE(
        operators::StellarEquilibriumBackendSpecificationList<models::ModelTypeList<eos::Polytrope, eos::Polytrope>>
    );
    STATIC_CHECK_FALSE(operators::StellarEquilibriumBackendSpecificationList<int>);
    STATIC_CHECK_FALSE(operators::stellarEquilibriumBackendRuntimeAuthorized<int, int>);
    STATIC_CHECK(operators::stellarEquilibriumBackendRuntimeAuthorized<eos::Polytrope, BaseModel>);
    STATIC_CHECK(operators::stellarEquilibriumBackendRuntimeAuthorized<models::FixedTotalMass, BaseModel>);

    STATIC_CHECK(
        operators::StellarEquilibriumCoreRuntime<
            stellar_runtime_contract_test::RegisteredWithoutMakeEquationOfState>::registered
    );
    STATIC_CHECK(operators::StellarEquilibriumSystemCompilable<RegisteredWithoutMakeModel>);
    STATIC_CHECK_FALSE(operators::hasStellarEquilibriumCoreRuntime<RegisteredWithoutMakeModel>);

    STATIC_CHECK(
        operators::PreparedStellarEquilibriumPhysicalCore<stellar_runtime_contract_test::AlternatePhysicalCore>
    );
    STATIC_CHECK(operators::hasStellarEquilibriumCoreRuntime<AlternateCoreModel>);
    STATIC_CHECK((std::same_as<
                  operators::StellarEquilibriumPhysicalCoreType<AlternateCoreModel>,
                  stellar_runtime_contract_test::AlternatePhysicalCore>));
    STATIC_CHECK(operators::hasCompleteStellarEquilibriumRuntime<AlternateCoreModel>);
    STATIC_CHECK(
        operators::stellarEquilibriumBackendRuntimeAuthorized<
            stellar_runtime_contract_test::AlternateCoreEquationOfState, AlternateCoreModel>
    );
    STATIC_CHECK(operators::stellarEquilibriumBackendRuntimeAuthorized<surface::Isobaric, AlternateCoreModel>);
    STATIC_CHECK(operators::stellarEquilibriumBackendRuntimeAuthorized<models::FixedTotalMass, AlternateCoreModel>);
    STATIC_CHECK(HasPreparedVariadicStellarEquilibriumOperator<AlternateCoreModel>);

    // Core support and constraint support are separate contracts.  This tiny
    // core supports the common outer root, but does not advertise the physical
    // facilities required by FixedAngularMomentum.
    STATIC_CHECK(operators::hasStellarEquilibriumCoreRuntime<AlternateCoreAngularMomentumModel>);
    STATIC_CHECK(
        operators::stellarEquilibriumBackendRuntimeAuthorized<
            models::FixedAngularMomentum, AlternateCoreAngularMomentumModel>
    );
    STATIC_CHECK_FALSE(operators::hasCompleteStellarEquilibriumRuntime<AlternateCoreAngularMomentumModel>);
    STATIC_CHECK_FALSE(HasPreparedVariadicStellarEquilibriumOperator<AlternateCoreAngularMomentumModel>);

    // The pack fold also rejects ambiguous physical-control ownership.  Both
    // contributions are independently executable, but exactly one runtime may
    // generate the rotation used by the shared physical core.
    STATIC_CHECK_FALSE(
        operators::StellarEquilibriumRuntimeContribution<
            stellar_runtime_contract_test::SecondRotationController>::registered
    );
    STATIC_CHECK(
        operators::StellarEquilibriumPhysicsAvailableFor<
            stellar_runtime_contract_test::SecondRotationController, TwoRotationProvidersModel>
    );
    STATIC_CHECK(operators::StellarEquilibriumSystemCompilable<TwoRotationProvidersModel>);
    STATIC_CHECK(operators::hasStellarEquilibriumCoreRuntime<TwoRotationProvidersModel>);
    STATIC_CHECK(operators::hasCompleteStellarEquilibriumRuntime<TwoRotationProvidersModel>);
    STATIC_CHECK(HasPreparedVariadicStellarEquilibriumOperator<TwoRotationProvidersModel>);
    STATIC_CHECK_FALSE(equilibrium::StellarEquilibriumModel<TwoRotationProvidersModel>);
    STATIC_CHECK(operators::stellarEquilibriumRotationProviderCount<TwoRotationProvidersModel> == 2);
    using AmbiguousRotationRoot = operators::PreparedVariadicStellarEquilibriumOperator<TwoRotationProvidersModel>;
    STATIC_CHECK_FALSE(
        std::constructible_from<
            AmbiguousRotationRoot, fem::FEM &, const mapping::DomainMapper &,
            std::shared_ptr<const TwoRotationProvidersModel>, operators::PressureSurfaceConstraintView,
            deformation::PreparedDomainDeformationRuntime>
    );

    // Report storage is part of the real runtime protocol: preparation creates
    // the complete report tuple and assigns each per-specification result into
    // it.  Capability queries must reject both failures without reaching a hard
    // error inside PreparedVariadicStellarEquilibriumOperator::Prepare().
    STATIC_CHECK(operators::StellarEquilibriumSystemCompilable<NonDefaultReportModel>);
    STATIC_CHECK_FALSE(
        operators::StellarEquilibriumPhysicsAvailableFor<
            stellar_runtime_contract_test::NonDefaultReportConstraint, NonDefaultReportModel>
    );
    STATIC_CHECK_FALSE(operators::hasCompleteStellarEquilibriumRuntime<NonDefaultReportModel>);
    STATIC_CHECK_FALSE(equilibrium::StellarEquilibriumModel<NonDefaultReportModel>);

    STATIC_CHECK(operators::StellarEquilibriumSystemCompilable<NonAssignableReportModel>);
    STATIC_CHECK_FALSE(
        operators::StellarEquilibriumPhysicsAvailableFor<
            stellar_runtime_contract_test::NonAssignableReportConstraint, NonAssignableReportModel>
    );
    STATIC_CHECK_FALSE(operators::hasCompleteStellarEquilibriumRuntime<NonAssignableReportModel>);
    STATIC_CHECK_FALSE(equilibrium::StellarEquilibriumModel<NonAssignableReportModel>);

    // Reports are deliberately opaque to the framework. Default construction
    // and assignment are sufficient for tuple storage; no DidAnyWork member is
    // required to keep the residual correct.
    STATIC_CHECK(operators::StellarEquilibriumSystemCompilable<OpaqueReportModel>);
    STATIC_CHECK(
        operators::StellarEquilibriumPhysicsAvailableFor<
            stellar_runtime_contract_test::OpaqueReportConstraint, OpaqueReportModel>
    );
    STATIC_CHECK(operators::hasCompleteStellarEquilibriumRuntime<OpaqueReportModel>);
    STATIC_CHECK(equilibrium::StellarEquilibriumModel<OpaqueReportModel>);

    // A nested declaration is the restricted physics-author path. Merely
    // implementing the former raw FEM/model/core/dependency protocol must not
    // recover the privileged backend access reserved for explicit registry
    // specializations.
    STATIC_CHECK(operators::StellarEquilibriumSystemCompilable<RawNestedProtocolModel>);
    STATIC_CHECK_FALSE(
        std::constructible_from<
            stellar_runtime_contract_test::PreparedRawNestedProtocolConstraint<RawNestedProtocolModel>,
            const stellar_runtime_contract_test::RawNestedProtocolConstraint &>
    );
    STATIC_CHECK_FALSE(
        operators::StellarEquilibriumPhysicsAvailableFor<
            stellar_runtime_contract_test::RawNestedProtocolConstraint, RawNestedProtocolModel>
    );
    STATIC_CHECK_FALSE(operators::hasCompleteStellarEquilibriumRuntime<RawNestedProtocolModel>);
    STATIC_CHECK_FALSE(equilibrium::StellarEquilibriumModel<RawNestedProtocolModel>);

    // Even a structurally complete aggregate runtime cannot select itself for
    // an existing core. Symbolic compilation and core availability remain
    // independently true, isolating authorization as the failed rung.
    STATIC_CHECK(operators::StellarEquilibriumSystemCompilable<UnauthorizedAggregateModel>);
    STATIC_CHECK(operators::hasStellarEquilibriumCoreRuntime<UnauthorizedAggregateModel>);
    STATIC_CHECK(
        operators::StellarEquilibriumRuntimeContribution<
            stellar_runtime_contract_test::UnauthorizedAggregateConstraint>::registered
    );
    STATIC_CHECK_FALSE(
        operators::stellarEquilibriumBackendRuntimeAuthorized<
            stellar_runtime_contract_test::UnauthorizedAggregateConstraint, UnauthorizedAggregateModel>
    );
    STATIC_CHECK_FALSE(
        operators::StellarEquilibriumPhysicsAvailableFor<
            stellar_runtime_contract_test::UnauthorizedAggregateConstraint, UnauthorizedAggregateModel>
    );
    STATIC_CHECK_FALSE(operators::hasCompleteStellarEquilibriumRuntime<UnauthorizedAggregateModel>);
    STATIC_CHECK_FALSE(equilibrium::StellarEquilibriumModel<UnauthorizedAggregateModel>);

    // A raw registry specialization cannot grant itself privileged access to
    // the built-in core and cannot shadow a valid restricted nested package.
    STATIC_CHECK(
        operators::StellarEquilibriumRuntimeContribution<
            stellar_runtime_contract_test::AmbiguousRuntimeRegistrationConstraint>::registered
    );
    STATIC_CHECK_FALSE(
        operators::stellarEquilibriumBackendRuntimeAuthorized<
            stellar_runtime_contract_test::AmbiguousRuntimeRegistrationConstraint, AmbiguousRuntimeRegistrationModel>
    );
    STATIC_CHECK(
        operators::StellarEquilibriumPhysicsAvailableFor<
            stellar_runtime_contract_test::AmbiguousRuntimeRegistrationConstraint, AmbiguousRuntimeRegistrationModel>
    );
    STATIC_CHECK(operators::hasCompleteStellarEquilibriumRuntime<AmbiguousRuntimeRegistrationModel>);
    STATIC_CHECK(equilibrium::StellarEquilibriumModel<AmbiguousRuntimeRegistrationModel>);

    // A core owner can deliberately authorize an aggregate backend candidate.
    // If that exact model then also supplies nested physics, the two valid
    // providers are genuinely ambiguous and are rejected.
    STATIC_CHECK(
        operators::stellarEquilibriumBackendRuntimeAuthorized<
            stellar_runtime_contract_test::AmbiguousRuntimeRegistrationConstraint,
            AuthorizedAmbiguousRuntimeRegistrationModel>
    );
    STATIC_CHECK_FALSE(
        operators::StellarEquilibriumPhysicsAvailableFor<
            stellar_runtime_contract_test::AmbiguousRuntimeRegistrationConstraint,
            AuthorizedAmbiguousRuntimeRegistrationModel>
    );
    STATIC_CHECK_FALSE(operators::hasCompleteStellarEquilibriumRuntime<AuthorizedAmbiguousRuntimeRegistrationModel>);
    STATIC_CHECK_FALSE(equilibrium::StellarEquilibriumModel<AuthorizedAmbiguousRuntimeRegistrationModel>);

    // A registration bit and a plausible core type are insufficient: the
    // factory must return ownership of the advertised concrete core.
    STATIC_CHECK_FALSE(operators::hasStellarEquilibriumCoreRuntime<WrongOwnerModel>);
    STATIC_CHECK_FALSE(operators::hasCompleteStellarEquilibriumRuntime<WrongOwnerModel>);

    STATIC_CHECK(
        operators::StellarEquilibriumRuntimeContribution<
            stellar_runtime_contract_test::IncompleteSurfaceRuntime>::registered
    );
    STATIC_CHECK_FALSE(
        operators::stellarEquilibriumBackendRuntimeAuthorized<
            stellar_runtime_contract_test::IncompleteSurfaceRuntime, IncompleteSurfaceRuntimeModel>
    );
    STATIC_CHECK(operators::StellarEquilibriumSystemCompilable<IncompleteSurfaceRuntimeModel>);
    STATIC_CHECK(operators::hasStellarEquilibriumCoreRuntime<IncompleteSurfaceRuntimeModel>);
    STATIC_CHECK_FALSE(operators::hasCompleteStellarEquilibriumRuntime<IncompleteSurfaceRuntimeModel>);
    STATIC_CHECK_FALSE(equilibrium::hasStellarEquilibriumSurfaceCompilation<IncompleteSurfaceRuntimeModel>);
    STATIC_CHECK_FALSE(equilibrium::StellarEquilibriumModel<IncompleteSurfaceRuntimeModel>);

    STATIC_CHECK_FALSE(operators::hasCompatibleStellarEquilibriumPhysicalRoot<MissingMassModel>);
    STATIC_CHECK_FALSE(HasPreparedVariadicStellarEquilibriumOperator<MissingMassModel>);

    STATIC_CHECK_FALSE(
        operators::CompilableRootManifestFor<
            CentralDensityModel, utils::blocks::surface_deformed_stellar_equilibrium_form>
    );
    STATIC_CHECK_FALSE(operators::CompilableRootManifestFor<BaseModel, CarrierlessManifestForm>);
    STATIC_CHECK_FALSE(
        operators::CompilableRootManifestFor<
            UnsupportedCentralDensityModel, operators::CompiledStellarEquilibriumForm<UnsupportedCentralDensityModel>>
    );

    // This declaration is internally well formed, but its dependency is not
    // supplied by the final model. Completeness is therefore contextual.
    STATIC_CHECK(operators::stellarEquilibriumSpecificationCompilationComplete<OrphanEndpoint>);
    STATIC_CHECK_FALSE(operators::StellarEquilibriumSystemCompilable<OrphanEndpointModel>);
    STATIC_CHECK_FALSE(HasCompiledStellarEquilibriumSystem<OrphanEndpointModel>);
}

TEST_CASE(
    "Direct Variadic Root Construction Requires Shared Model Ownership",
    "[stellar-equilibrium][runtime][lifetime][type-contract]"
) {
    using namespace mean_field;
    using Operator = operators::PreparedVariadicStellarEquilibriumOperator<BaseModel>;

    STATIC_CHECK_FALSE(
        std::constructible_from<
            Operator, fem::FEM &, const mapping::DomainMapper &, const BaseModel &,
            operators::PressureSurfaceConstraintView, deformation::PreparedDomainDeformationRuntime>
    );
    STATIC_CHECK(
        std::constructible_from<
            Operator, fem::FEM &, const mapping::DomainMapper &, std::shared_ptr<const BaseModel>,
            operators::PressureSurfaceConstraintView, deformation::PreparedDomainDeformationRuntime>
    );
}

TEST_CASE(
    "Physical Riesz Runtime Capability Follows The Selected Core",
    "[normalization][stellar-equilibrium][type-contract]"
) {
    using namespace mean_field;
    using AlternateForm           = operators::CompiledStellarEquilibriumForm<AlternateCoreModel>;
    using AlternateSpecifications = AlternateCoreModel::SpecificationTypes;

    STATIC_CHECK(normalization::PhysicalRieszStellarEquilibriumCore<operators::PreparedStellarEquilibriumOperator>);
    STATIC_CHECK_FALSE(
        normalization::PhysicalRieszStellarEquilibriumCore<stellar_runtime_contract_test::AlternatePhysicalCore>
    );
    STATIC_CHECK(
        normalization::PhysicalRieszStellarEquilibriumCore<stellar_runtime_contract_test::PhysicalRieszCapableCore>
    );
    STATIC_CHECK(
        normalization::StellarNormalizationRuntimeAvailableFor<
            normalization::Unnormalized, AlternateForm, stellar_runtime_contract_test::AlternatePhysicalCore,
            AlternateSpecifications>
    );
    STATIC_CHECK_FALSE(
        normalization::StellarNormalizationRuntimeAvailableFor<
            normalization::PhysicalRieszDiagonal<>, AlternateForm, stellar_runtime_contract_test::AlternatePhysicalCore,
            AlternateSpecifications>
    );
    STATIC_CHECK(
        normalization::StellarNormalizationRuntimeAvailableFor<
            normalization::PhysicalRieszDiagonal<>, AlternateForm,
            stellar_runtime_contract_test::PhysicalRieszCapableCore, AlternateSpecifications>
    );
    STATIC_CHECK_FALSE(normalization::StellarNormalizationRuntimeAvailableFor<int, int, int, int>);

    // Runtime normalization is selected by the discretization type. A lean
    // alternate core remains fully usable without scaling, while the Physical
    // Riesz pairing is rejected at the public capability boundary rather than
    // failing in the normalized operator's constructor body.
    STATIC_CHECK(equilibrium::StellarEquilibriumModel<AlternateCoreModel>);
    STATIC_CHECK(
        equilibrium::StellarEquilibriumModelDiscretizationCompatible<
            AlternateCoreModel, equilibrium::StellarDiscretization>
    );
    STATIC_CHECK_FALSE(
        equilibrium::StellarEquilibriumModelDiscretizationCompatible<AlternateCoreModel, PhysicalRieszDiscretization>
    );
    STATIC_CHECK_FALSE(HasStellarEquilibriumProblem<AlternateCoreModel, PhysicalRieszDiscretization>);
    STATIC_CHECK_FALSE(CanDiscretizeStellarModel<AlternateCoreModel, PhysicalRieszDiscretization>);
    STATIC_CHECK(normalization::NormalizableStellarEquilibriumProblem<BaseProblem>);
    STATIC_CHECK(normalization::PhysicalRieszStellarEquilibriumProblem<BasePhysicalRieszProblem>);
    STATIC_CHECK(normalization::NormalizableStellarEquilibriumProblem<BasePhysicalRieszProblem>);
    STATIC_CHECK(normalization::NormalizableStellarEquilibriumProblem<AlternateCoreProblem>);
    STATIC_CHECK_FALSE(normalization::PhysicalRieszStellarEquilibriumProblem<int>);
    STATIC_CHECK_FALSE(normalization::NormalizableStellarEquilibriumProblem<int>);

    STATIC_CHECK(HasNormalizedStellarEquilibriumOperator<BaseProblem>);
    STATIC_CHECK(HasNormalizedStellarEquilibriumOperator<BasePhysicalRieszProblem>);
    STATIC_CHECK(HasNormalizedStellarEquilibriumOperator<AlternateCoreProblem>);
    STATIC_CHECK(CanMakeNormalizedStellarEquilibriumOperator<BaseProblem>);
    STATIC_CHECK(CanMakeNormalizedStellarEquilibriumOperator<AlternateCoreProblem>);
    STATIC_CHECK_FALSE(CanMakeNormalizedStellarEquilibriumOperator<int>);
}

TEST_CASE(
    "Model And Discretization Compatibility Rejects Missing Riesz "
    "Metadata Without Instantiating A Problem",
    "[normalization][stellar-equilibrium][type-contract][sfinae]"
) {
    using namespace mean_field;
    using MissingRieszForm  = operators::CompiledStellarEquilibriumForm<MissingRieszModel>;
    using MissingConstraint = stellar_runtime_contract_test::MissingRieszScalarConstraint;

    // Every non-normalization rung is complete for this model.
    STATIC_CHECK(equilibrium::StellarEquilibriumModel<MissingRieszModel>);
    STATIC_CHECK(operators::StellarEquilibriumSystemCompilable<MissingRieszModel>);
    STATIC_CHECK(operators::hasCompleteStellarEquilibriumRuntime<MissingRieszModel>);
    STATIC_CHECK(operators::CompilableRootManifestFor<MissingRieszModel, MissingRieszForm>);
    STATIC_CHECK(models::CompleteGeneratedManifestFor<MissingConstraint>);

    // Identity normalization covers the generated pair without physical scale
    // metadata. Physical Riesz correctly requires that missing declaration.
    STATIC_CHECK_FALSE(models::CompleteGeneratedNormalizationFor<MissingConstraint>);
    STATIC_CHECK_FALSE(normalization::CompleteGeneratedPhysicalRieszNormalizationFor<MissingConstraint>);
    STATIC_CHECK_FALSE(normalization::CompleteGeneratedPhysicalRieszRuntimeNormalizationFor<MissingConstraint>);
    STATIC_CHECK(normalization::CompleteGeneratedPhysicalRieszRuntimeNormalizationFor<models::FixedTotalMass>);
    STATIC_CHECK(normalization::CompilableNormalizationFor<normalization::Unnormalized, MissingRieszForm>);
    STATIC_CHECK_FALSE(
        normalization::CompilableNormalizationFor<normalization::PhysicalRieszDiagonal<>, MissingRieszForm>
    );
    STATIC_CHECK_FALSE(normalization::CompleteStellarNormalizationFor<MissingRieszModel, MissingRieszForm>);

    STATIC_CHECK(
        equilibrium::StellarEquilibriumModelDiscretizationCompatible<
            MissingRieszModel, equilibrium::StellarDiscretization>
    );
    STATIC_CHECK_FALSE(
        equilibrium::StellarEquilibriumModelDiscretizationCompatible<MissingRieszModel, PhysicalRieszDiscretization>
    );
    STATIC_CHECK_FALSE(equilibrium::StellarEquilibriumModelDiscretizationCompatible<int, int>);

    STATIC_CHECK(HasStellarEquilibriumProblem<MissingRieszModel, equilibrium::StellarDiscretization>);
    STATIC_CHECK_FALSE(HasStellarEquilibriumProblem<MissingRieszModel, PhysicalRieszDiscretization>);
    STATIC_CHECK_FALSE(HasStellarEquilibriumProblem<int, int>);
    STATIC_CHECK(CanDiscretizeStellarModel<MissingRieszModel, equilibrium::StellarDiscretization>);
    STATIC_CHECK_FALSE(CanDiscretizeStellarModel<MissingRieszModel, PhysicalRieszDiscretization>);

    STATIC_CHECK(equilibrium::DiscretizedStellarEquilibriumProblem<MissingRieszUnnormalizedProblem>);
    STATIC_CHECK(normalization::NormalizableStellarEquilibriumProblem<MissingRieszUnnormalizedProblem>);
}

TEST_CASE(
    "Restricted Equilibrium Physics Automatically Supplies The Default "
    "Constraint Border",
    "[preconditioning][stellar-equilibrium][type-contract][sfinae]"
) {
    using namespace mean_field;

    // The ordinary nested provider is the single source of numerical formulas.
    // Border-incident edges are projected from it automatically, while the
    // custom pure-structure edge is explicitly proven to be StructuralZero.
    STATIC_CHECK(equilibrium::StellarEquilibriumModel<MissingRieszModel>);
    STATIC_CHECK(operators::hasCompleteStellarEquilibriumRuntime<MissingRieszModel>);
    STATIC_CHECK(equilibrium::DiscretizedStellarEquilibriumProblem<MissingRieszUnnormalizedProblem>);
    STATIC_CHECK(preconditioning::CompleteSpecificationBorderActionsFor<MissingRieszUnnormalizedProblem>);
    STATIC_CHECK(preconditioning::DefaultStellarPreconditionerAvailableFor<MissingRieszUnnormalizedProblem>);
    STATIC_CHECK(CanMakeDefaultStellarPreconditioner<MissingRieszUnnormalizedProblem>);
}