Enforce strict root public API QA

ChrisRackauckas · ChrisRackauckas · commit 5a3381cd3de1 · 2026-07-30T00:09:12.000-04:00
Co-Authored-By: Chris Rackauckas &lt;accounts@chrisrackauckas.com&gt;
diff --git a/Project.toml b/Project.toml
@@ -3,21 +3,14 @@ uuid = "764a87c0-6b3e-53db-9096-fe964310641d"
 version = "5.23.2"
 
 [deps]
-ADTypes = "47edcb42-4c32-4615-8424-f2b9edc5f35b"
 BoundaryValueDiffEqAscher = "7227322d-7511-4e07-9247-ad6ff830280e"
 BoundaryValueDiffEqCore = "56b672f2-a5fe-4263-ab2d-da677488eb3a"
 BoundaryValueDiffEqFIRK = "85d9eb09-370e-4000-bb32-543851f73618"
 BoundaryValueDiffEqMIRK = "1a22d4ce-7765-49ea-b6f2-13c8438986a6"
 BoundaryValueDiffEqMIRKN = "9255f1d6-53bf-473e-b6bd-23f1ff009da4"
 BoundaryValueDiffEqShooting = "ed55bfe0-3725-4db6-871e-a1dc9f42a757"
-DiffEqBase = "2b5f629d-d688-5b77-993f-72d75c75574e"
-FastClosures = "9aa1b823-49e4-5ca5-8b0f-3971ec8bab6a"
-ForwardDiff = "f6369f11-7733-5829-9624-2563aa707210"
-LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
 OrdinaryDiffEqTsit5 = "b1df2697-797e-41e3-8120-5422d3b24e4a"
-Reexport = "189a3867-3050-52da-a836-e630ba90ab69"
 SciMLBase = "0bca4576-84f4-4d90-8ffe-ffa030f20462"
-SciMLLogging = "a6db7da4-7206-11f0-1eab-35f2a5dbe1d1"
 
 [weakdeps]
 ODEInterface = "54ca160b-1b9f-5127-a996-1867f4bc2a2c"
@@ -33,11 +26,8 @@ BoundaryValueDiffEqFIRK = "1.17.2"
 BoundaryValueDiffEqMIRK = "1.17.2"
 BoundaryValueDiffEqMIRKN = "1.16.2"
 BoundaryValueDiffEqShooting = "1.17.3"
-DiffEqBase = "6.183, 7"
 DiffEqDevTools = "2.48, 3"
 DifferentiationInterface = "0.7.15"
-FastClosures = "0.3.2"
-ForwardDiff = "0.10.38, 1"
 LinearAlgebra = "1.10"
 LinearSolve = "3.87, 4, 5"
 NonlinearSolveBase = "2"
@@ -49,19 +39,19 @@ OptimizationBase = "5"
 Pkg = "1.10.0"
 Random = "1.10"
 RecursiveArrayTools = "3.31.2, 4"
-Reexport = "1.2"
 SafeTestsets = "0.1.0"
 SciMLBase = "3.30"
-SciMLLogging = "1.10.1, 2"
 SciMLTesting = "2.4"
 Sparspak = "0.3.11"
 StaticArrays = "1.9.8"
 Test = "1.10"
 julia = "1.10"
 
 [extras]
+ADTypes = "47edcb42-4c32-4615-8424-f2b9edc5f35b"
 DiffEqDevTools = "f3b72e0c-5b89-59e1-b016-84e28bfd966d"
 DifferentiationInterface = "a0c0ee7d-e4b9-4e03-894e-1c5f64a51d63"
+LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
 LinearSolve = "7ed4a6bd-45f5-4d41-b270-4a48e9bafcae"
 NonlinearSolveBase = "be0214bd-f91f-a760-ac4e-3421ce2b2da0"
 NonlinearSolveFirstOrder = "5959db7a-ea39-4486-b5fe-2dd0bf03d60d"
@@ -78,4 +68,4 @@ StaticArrays = "90137ffa-7385-5640-81b9-e52037218182"
 Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
 
 [targets]
-test = ["DiffEqDevTools", "DifferentiationInterface", "LinearSolve", "NonlinearSolveFirstOrder", "OrdinaryDiffEqLowOrderRK", "OrdinaryDiffEqTsit5", "Pkg", "Random", "RecursiveArrayTools", "SafeTestsets", "SciMLTesting", "Sparspak", "StaticArrays", "Test", "OptimizationBase", "NonlinearSolveBase"]
+test = ["ADTypes", "DiffEqDevTools", "DifferentiationInterface", "LinearAlgebra", "LinearSolve", "NonlinearSolveFirstOrder", "OrdinaryDiffEqLowOrderRK", "OrdinaryDiffEqTsit5", "Pkg", "Random", "RecursiveArrayTools", "SafeTestsets", "SciMLTesting", "Sparspak", "StaticArrays", "Test", "OptimizationBase", "NonlinearSolveBase"]
diff --git a/docs/make.jl b/docs/make.jl
@@ -5,7 +5,7 @@ using BoundaryValueDiffEqCore, BoundaryValueDiffEqMIRK, BoundaryValueDiffEqFIRK,
     BoundaryValueDiffEqMIRKN
 using BoundaryValueDiffEqShooting
 using BoundaryValueDiffEqAscher
-using SciMLBase, DiffEqBase
+using SciMLBase
 using BoundaryValueDiffEq
 using SimpleBoundaryValueDiffEq
 
@@ -27,12 +27,10 @@ makedocs(;
     modules = [
         BoundaryValueDiffEqCore, BoundaryValueDiffEqMIRK, BoundaryValueDiffEqFIRK,
         BoundaryValueDiffEqMIRKN, BoundaryValueDiffEqShooting, BoundaryValueDiffEqAscher,
-        SciMLBase, DiffEqBase, BoundaryValueDiffEq, SimpleBoundaryValueDiffEq,
+        BoundaryValueDiffEq,
     ],
     clean = true,
-    doctest = false,
     checkdocs = :exports,
-    warnonly = [:missing_docs, :cross_references],
     plugins = [bib, interlinks],
     format = Documenter.HTML(
         assets = ["assets/favicon.ico"],
diff --git a/docs/src/basics/autodiff.md b/docs/src/basics/autodiff.md
@@ -12,8 +12,8 @@ BVPJacobianAlgorithm
 
 In BoundaryValueDiffEq.jl, automatic differentiation backend should only be wrapped in `BVPJacobianAlgorithm(diffmode, bc_diffmode, nonbc_diffmode)`. `BVPJacobianAlgorithm(diffmode, bc_diffmode, nonbc_diffmode)` supports user-specified mixed automatic differentiation backends in different part of a boundary value problem, and AD choice should depended on the type of boundary value problem:
 
-  - [`BVProblem`](@ref SciMLBase.BVProblem): Differentiation mode for boundary condition part and non boundary condition part should be specified, for example, `BVPJacobianAlgorithm(; bc_diffmode, nonbc_diffmode)`, default to `BVPJacobianAlgorithm(; bc_diffmode = AutoForwardDiff(), nonbc_diffmode = AutoSparse(AutoForwardDiff()))`.
-  - [`TwoPointBVProblem`](@ref SciMLBase.TwoPointBVProblem): Differentiation mode for overall solving should be specified, for example, `BVPJacobianAlgorithm(; diffmode)`, default to `BVPJacobianAlgorithm(; diffmode = AutoSparse(AutoForwardDiff()))`.
+  - `BVProblem`: Differentiation mode for boundary condition part and non boundary condition part should be specified, for example, `BVPJacobianAlgorithm(; bc_diffmode, nonbc_diffmode)`, default to `BVPJacobianAlgorithm(; bc_diffmode = AutoForwardDiff(), nonbc_diffmode = AutoSparse(AutoForwardDiff()))`.
+  - `TwoPointBVProblem`: Differentiation mode for overall solving should be specified, for example, `BVPJacobianAlgorithm(; diffmode)`, default to `BVPJacobianAlgorithm(; diffmode = AutoSparse(AutoForwardDiff()))`.
 
 In BoundaryValueDiffEq.jl, we require AD to obtain the Jacobian of the loss function which contains the collocation equation and boundary condition equations. For `TwoPointBVProblem`, the Jacobian of the loss function is a sparse banded matrix with known sparsity pattern, but for general multi-points `BVProblem`, the Jacobian of the loss function is an almost banded matrix, which has the first several rows as the boundary conditions and the rest as a sparse banded matrix with known sparsity pattern but without the first several rows. In this case, we can specify mixed AD backend in `BVPJacobianAlgorithm` to make the most of the different sparsity pattern to accelerate BVP solving process.
 
diff --git a/docs/src/basics/bvp_functions.md b/docs/src/basics/bvp_functions.md
@@ -4,7 +4,5 @@ The SciML ecosystem provides an extensive interface for declaring extra function
 
 ## Function Type Definitions
 
-```@docs
-SciMLBase.BVPFunction
-SciMLBase.DynamicalBVPFunction
-```
+See SciMLBase for the full constructor contracts of `BVPFunction` and
+`DynamicalBVPFunction`.
diff --git a/docs/src/basics/bvp_problem.md b/docs/src/basics/bvp_problem.md
@@ -12,9 +12,9 @@ BoundaryValueDiffEq.jl tackles five related types of boundary value problems:
 
 ## Problem Construction Details
 
-```@docs
-BVProblem
-TwoPointBVProblem
-SecondOrderBVProblem
-TwoPointSecondOrderBVProblem
-```
+These problem constructors are defined by SciMLBase:
+
+  - `BVProblem`
+  - `TwoPointBVProblem`
+  - `SecondOrderBVProblem`
+  - `TwoPointSecondOrderBVProblem`
diff --git a/docs/src/basics/verbosity.md b/docs/src/basics/verbosity.md
@@ -10,6 +10,7 @@ Pass a `BVPVerbosity` object to `solve` or `init` using the `verbose` keyword ar
 
 ```julia
 using BoundaryValueDiffEq
+using SciMLBase: BVProblem, init, solve
 
 # Define a boundary value problem
 function f!(du, u, p, t)
diff --git a/docs/src/tutorials/continuation.md b/docs/src/tutorials/continuation.md
@@ -21,6 +21,7 @@ Since this BVP would become difficult to solve when ``0<ε\ll 1``, we start the
 
 ```@example continuation
 using BoundaryValueDiffEq, Plots
+using SciMLBase: BVProblem, solve
 function f!(du, u, p, t)
     du[1] = u[2]
     du[2] = -t / p * u[2] - pi^2 * cospi(t) - pi * t / p * sinpi(t)
diff --git a/docs/src/tutorials/extremum.md b/docs/src/tutorials/extremum.md
@@ -13,6 +13,8 @@ where `lb=-4.8161991710010925` and `ub=5.0496477654230745`. So the states must c
 
 ```@example inequality
 using BoundaryValueDiffEq
+using ADTypes: AutoFiniteDiff, AutoSparse
+using SciMLBase: BVProblem, solve
 tspan = (0.0, pi / 2)
 function simplependulum!(du, u, p, t)
     θ = u[1]
diff --git a/docs/src/tutorials/getting_started.md b/docs/src/tutorials/getting_started.md
@@ -19,6 +19,7 @@ Consider the linear two-point boundary value problem from [standard BVP test pro
 
 ```@example getting_started
 using BoundaryValueDiffEq
+using SciMLBase: BVProblem, SecondOrderBVProblem, TwoPointBVProblem, solve
 function f!(du, u, p, t)
     du[1] = u[2]
     du[2] = u[1]
diff --git a/docs/src/tutorials/optimal_control.md b/docs/src/tutorials/optimal_control.md
@@ -170,7 +170,7 @@ c = 0.5 * sqrt(g_0 * h_0)    # Thrust-to-fuel mass
 D_c = 0.5 * 620 * m_0 / g_0  # Drag scaling
 u_t_max = 3.5 * g_0 * m_0    # Maximum thrust
 T_max = 0.2                  # Number of seconds
-T = 1_000                    # Number of time steps
+T = 100                      # Number of time steps
 Δt = 0.2 / T;                # Time per discretized step
 
 tspan = (0.0, 0.2)
diff --git a/docs/src/tutorials/solve_nlls_bvp.md b/docs/src/tutorials/solve_nlls_bvp.md
@@ -27,6 +27,7 @@ The test BVP has two state variables but three boundary conditions, which means
 
 ```@example nlls_overdetermined
 using BoundaryValueDiffEq, Plots
+using SciMLBase: BVPFunction, BVProblem, TwoPointBVProblem, solve
 function f!(du, u, p, t)
     du[1] = u[2]
     du[2] = -u[1]
@@ -80,6 +81,7 @@ y_4' &= 0
 
 ```@example nlls_underdetermined
 using BoundaryValueDiffEq, Plots
+using SciMLBase: BVPFunction, BVProblem, TwoPointBVProblem, solve
 function f!(du, u, p, t)
     du[1] = u[2]
     du[2] = u[3]
diff --git a/docs/src/tutorials/unknown_parameters.md b/docs/src/tutorials/unknown_parameters.md
@@ -35,6 +35,7 @@ With BoundaryValueDiffEq.jl, it's easy to solve boundary value problems with unk
 
 ```@example unknown
 using BoundaryValueDiffEq, Plots
+using SciMLBase: TwoPointBVProblem, solve
 tspan = (0.0, pi)
 function f!(du, u, p, t)
     du[1] = u[2]
diff --git a/src/BoundaryValueDiffEq.jl b/src/BoundaryValueDiffEq.jl
@@ -1,55 +1,39 @@
 module BoundaryValueDiffEq
 
-using ADTypes: ADTypes
-using BoundaryValueDiffEqAscher: BoundaryValueDiffEqAscher, Ascher1, Ascher2, Ascher3,
-    Ascher4, Ascher5, Ascher6, Ascher7
-using BoundaryValueDiffEqCore: BoundaryValueDiffEqCore,
-    AbstractBoundaryValueDiffEqAlgorithm, BVPJacobianAlgorithm, BVPVerbosity,
-    DEFAULT_VERBOSE
-using BoundaryValueDiffEqFIRK: BoundaryValueDiffEqFIRK, LobattoIIIa2, LobattoIIIa3,
-    LobattoIIIa4, LobattoIIIa5, LobattoIIIb2, LobattoIIIb3, LobattoIIIb4, LobattoIIIb5,
-    LobattoIIIc2, LobattoIIIc3, LobattoIIIc4, LobattoIIIc5, RadauIIa1, RadauIIa2,
-    RadauIIa3, RadauIIa5, RadauIIa7
-using BoundaryValueDiffEqMIRK: BoundaryValueDiffEqMIRK, MIRK2, MIRK3, MIRK4, MIRK5,
-    MIRK6, maxsol, minsol
-using BoundaryValueDiffEqMIRKN: BoundaryValueDiffEqMIRKN, MIRKN4, MIRKN6
-using BoundaryValueDiffEqShooting: BoundaryValueDiffEqShooting, MultipleShooting, Shooting
-using DiffEqBase: DiffEqBase, solve
+using BoundaryValueDiffEqAscher: Ascher1, Ascher2, Ascher3, Ascher4, Ascher5, Ascher6,
+    Ascher7
+using BoundaryValueDiffEqCore: AbstractBoundaryValueDiffEqAlgorithm, BVPJacobianAlgorithm,
+    BVPVerbosity, DEFAULT_VERBOSE
+using BoundaryValueDiffEqFIRK: LobattoIIIa2, LobattoIIIa3, LobattoIIIa4, LobattoIIIa5,
+    LobattoIIIb2, LobattoIIIb3, LobattoIIIb4, LobattoIIIb5, LobattoIIIc2, LobattoIIIc3,
+    LobattoIIIc4, LobattoIIIc5, RadauIIa1, RadauIIa2, RadauIIa3, RadauIIa5, RadauIIa7
+using BoundaryValueDiffEqMIRK: MIRK2, MIRK3, MIRK4, MIRK5, MIRK6, maxsol, minsol
+using BoundaryValueDiffEqMIRKN: MIRKN4, MIRKN6
+using BoundaryValueDiffEqShooting: MultipleShooting, Shooting
 using OrdinaryDiffEqTsit5: Tsit5
-using Reexport: @reexport
-using SciMLBase: SciMLBase, BVProblem
+using SciMLBase: SciMLBase
 
-@reexport using ADTypes, SciMLBase
-
-function SciMLBase.__init(prob::BVProblem; kwargs...)
+function SciMLBase.__init(prob::SciMLBase.BVProblem; kwargs...)
     return SciMLBase.__init(prob, Shooting(Tsit5()); kwargs...)
 end
 
-function SciMLBase.__solve(prob::BVProblem; kwargs...)
+function SciMLBase.__solve(prob::SciMLBase.BVProblem; kwargs...)
     return SciMLBase.__solve(prob, Shooting(Tsit5()); kwargs...)
 end
 
 include("extension_algs.jl")
 
-export MIRK2, MIRK3, MIRK4, MIRK5, MIRK6
+export BVPM2, BVPSOL, COLNEW # From ODEInterface.jl
 
+export MIRK2, MIRK3, MIRK4, MIRK5, MIRK6
 export Shooting, MultipleShooting
-
 export RadauIIa1, RadauIIa2, RadauIIa3, RadauIIa5, RadauIIa7
 export LobattoIIIa2, LobattoIIIa3, LobattoIIIa4, LobattoIIIa5
 export LobattoIIIb2, LobattoIIIb3, LobattoIIIb4, LobattoIIIb5
 export LobattoIIIc2, LobattoIIIc3, LobattoIIIc4, LobattoIIIc5
-
 export MIRKN4, MIRKN6
-
 export Ascher1, Ascher2, Ascher3, Ascher4, Ascher5, Ascher6, Ascher7
-
-export BVPM2, BVPSOL, COLNEW # From ODEInterface.jl
-
-export BVPJacobianAlgorithm
-
-export BVPVerbosity, DEFAULT_VERBOSE
-
+export BVPJacobianAlgorithm, BVPVerbosity, DEFAULT_VERBOSE
 export maxsol, minsol
 
 end
diff --git a/src/extension_algs.jl b/src/extension_algs.jl
@@ -38,6 +38,7 @@ Fortran code for solving two-point boundary value problems. For detailed documen
 
 ```julia
 using BoundaryValueDiffEq, ODEInterface
+using SciMLBase: solve
 
 alg = BVPM2(max_num_subintervals = 5000, method_choice = 4)
 sol = solve(prob, alg)
@@ -107,6 +108,7 @@ For detailed documentation, see
 
 ```julia
 using BoundaryValueDiffEq, ODEInterface
+using SciMLBase: solve
 
 alg = BVPSOL(bvpclass = 1, sol_method = 0)
 sol = solve(prob, alg)
@@ -179,6 +181,7 @@ the linear and nonlinear algebraic equation solvers.
 
 ```julia
 using BoundaryValueDiffEq, ODEInterface
+using SciMLBase: solve
 
 alg = COLNEW(collocationpts = 7, max_num_subintervals = 5000)
 sol = solve(prob, alg)
diff --git a/test/misc/adaptivity_tests.jl b/test/misc/adaptivity_tests.jl
@@ -1,4 +1,5 @@
 using BoundaryValueDiffEq
+using SciMLBase: BVProblem, TwoPointBVProblem, solve
 using Test
 
 @testset "Mesh redistribution in adaptivity" begin
diff --git a/test/misc/bigfloat_test.jl b/test/misc/bigfloat_test.jl
@@ -1,4 +1,5 @@
 using BoundaryValueDiffEq
+using SciMLBase: SciMLBase, BVPFunction, BVProblem, SecondOrderBVProblem, solve
 using Test
 
 @testset "BigFloat compatibility" begin
diff --git a/test/misc/default_solvers.jl b/test/misc/default_solvers.jl
@@ -1,4 +1,5 @@
 using BoundaryValueDiffEq
+using SciMLBase: BVProblem, solve
 using Test
 
 @testset "Default Solvers" begin
diff --git a/test/misc/initial_guess_tests.jl b/test/misc/initial_guess_tests.jl
@@ -1,4 +1,6 @@
 using BoundaryValueDiffEq
+import SciMLBase
+using SciMLBase: BVProblem, solve
 using Test
 
 @testset "Initial guess providing" begin
diff --git a/test/misc/manifolds_tests.jl b/test/misc/manifolds_tests.jl
@@ -1,4 +1,5 @@
 using BoundaryValueDiffEq
+using SciMLBase: BVProblem, solve
 using Test
 
 @testset "Manifolds.jl Integration" begin
diff --git a/test/misc/non_vector_input_tests.jl b/test/misc/non_vector_input_tests.jl
@@ -1,4 +1,5 @@
 using BoundaryValueDiffEq
+using SciMLBase: BVProblem, TwoPointBVProblem, solve
 using Test
 
 @testset "Non-Vector Inputs" begin
diff --git a/test/misc/scalar_tests.jl b/test/misc/scalar_tests.jl
@@ -1,4 +1,5 @@
 using BoundaryValueDiffEq
+using SciMLBase: TwoPointBVProblem, solve
 using Test
 
 @testset "Scalar BVP tests" begin
diff --git a/test/misc/type_stability_tests.jl b/test/misc/type_stability_tests.jl
@@ -1,4 +1,6 @@
 using BoundaryValueDiffEq
+using ADTypes: AutoForwardDiff
+using SciMLBase: BVPFunction, BVProblem, SecondOrderBVProblem, TwoPointBVProblem, solve
 using Test
 
 @testset "Type Stability" begin
diff --git a/test/misc/verbose_tests.jl b/test/misc/verbose_tests.jl
@@ -1,4 +1,5 @@
 using BoundaryValueDiffEq
+using SciMLBase: BVProblem, SecondOrderBVProblem, init, solve
 using Test
 
 @testset "Verbose field in caches" begin
diff --git a/test/qa/qa.jl b/test/qa/qa.jl
@@ -4,14 +4,30 @@ using SciMLBase
 using JET
 using Test
 
-include("reexports.jl")
+const ROOT_FACADE_REEXPORTS = (
+    :Ascher1, :Ascher2, :Ascher3, :Ascher4, :Ascher5, :Ascher6, :Ascher7,
+    :BVPJacobianAlgorithm, :BVPVerbosity, :DEFAULT_VERBOSE,
+    :LobattoIIIa2, :LobattoIIIa3, :LobattoIIIa4, :LobattoIIIa5,
+    :LobattoIIIb2, :LobattoIIIb3, :LobattoIIIb4, :LobattoIIIb5,
+    :LobattoIIIc2, :LobattoIIIc3, :LobattoIIIc4, :LobattoIIIc5,
+    :MIRK2, :MIRK3, :MIRK4, :MIRK5, :MIRK6, :MIRKN4, :MIRKN6,
+    :MultipleShooting,
+    :RadauIIa1, :RadauIIa2, :RadauIIa3, :RadauIIa5, :RadauIIa7,
+    :Shooting, :maxsol, :minsol,
+)
+
+@testset "Facade dependency bindings" begin
+    @test !isdefined(BoundaryValueDiffEq, :BVProblem)
+    @test !isdefined(BoundaryValueDiffEq, :AutoForwardDiff)
+    @test !Base.ispublic(BoundaryValueDiffEq, :SciMLBase)
+    @test !Base.ispublic(BoundaryValueDiffEq, :ADTypes)
+end
 
 run_qa(
     BoundaryValueDiffEq;
     aqua_kwargs = (;
         ambiguities = false,
         piracies = (; treat_as_own = [SciMLBase.BVProblem]),
     ),
-    reexports_allow = ROOT_REEXPORTS,
-    api_docs_kwargs = (; ignore = ROOT_REEXPORTS, rendered_ignore = ROOT_REEXPORTS),
+    reexports_allow = ROOT_FACADE_REEXPORTS,
 )
diff --git a/test/qa/reexports.jl b/test/qa/reexports.jl
diff --git a/test/wrappers/odeinterface_tests.jl b/test/wrappers/odeinterface_tests.jl
