QA: eliminate ExplicitImports exceptions (make-public Core API, explicit imports)

Replaces the blanket `ei_broken` suppressions added in the run_qa v1.6
conversion with real fixes, so QA enforces ExplicitImports instead of masking
entire check categories.

Core (BoundaryValueDiffEqCore):
- Mark the internal API consumed by the solver sublibraries `@public` via
  SciMLPublic (no-op on Julia <1.11). This lets the sublibraries import those
  names without `all_explicit_imports_are_public` / `all_qualified_accesses`
  flags, eliminating the bulk of the suppressions fleet-wide.
- Make implicit imports explicit, drop stale imports, define a local
  `_unwrap_val` (SciMLBase internal that won't be made public).
- Remaining qa.jl ignores are genuine external internals only (ForwardDiff,
  SciMLStructures, SparseConnectivityTracer, ArrayInterface.parameterless_type,
  and SciMLBase BVP problem/algorithm types + solution_new_original_retcode).

Sublibraries (Ascher, Shooting, MIRK, MIRKN, FIRK):
- Make all implicit imports explicit; remove stale imports; import `get_tmp`
  from its owner PreallocationTools and `@SciMLMessage` from SciMLLogging.
- Drop now-unused deps (MIRKN: ArrayInterface/BandedMatrices/
  FastAlmostBandedMatrices/PrecompileTools/SparseArrays; Ascher:
  PreallocationTools/RecursiveArrayTools; Shooting: RecursiveArrayTools).
- Now-public SciMLBase names (`__solve`/`__init`/`build_solution`/... in 3.30)
  no longer need ignores; bump SciMLBase compat floor to 3.30.
- All ei_broken removed; remaining ignores are external non-public names only
  (StandardBVProblem/StandardSecondOrderBVProblem, ForwardDiff Dual/jacobian!/
  pickchunksize, SciMLStructures Tunable/canonicalize/isscimlstructure).

Umbrella (BoundaryValueDiffEq): explicitly import the re-exported solver
algorithms from each sublibrary; ei_broken/ignores removed entirely.

Verified locally on Julia 1.12 (released SciMLBase 3.30.0, SciMLTesting 1.7.0):
GROUP=QA run_qa green for root (17/17) and all six sublibraries, 0 broken.

Co-Authored-By: Chris Rackauckas <accounts@chrisrackauckas.com>

Author: ChrisRackauckas

Project.toml

@@ -17,6 +17,7 @@ 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"
@@ -58,7 +59,8 @@ Random = "1.10"
 RecursiveArrayTools = "3.31.2, 4"
 Reexport = "1.2"
 SafeTestsets = "0.1.0"
-SciMLBase = "3"
+SciMLBase = "3.30"
+SciMLLogging = "1.10.1, 2"
 SciMLTesting = "1"
 Sparspak = "0.3.11"
 StaticArrays = "1.9.8"

ext/BoundaryValueDiffEqODEInterfaceExt.jl

@@ -3,8 +3,9 @@ module BoundaryValueDiffEqODEInterfaceExt
 using BoundaryValueDiffEq: BVPM2, BVPSOL, COLNEW
 using BoundaryValueDiffEqCore: __extract_u0, __initial_guess_length, __extract_mesh,
     __flatten_initial_guess, __get_bcresid_prototype,
-    __has_initial_guess, __initial_guess, _process_verbose_param, BVPVerbosity, @SciMLMessage
+    __has_initial_guess, __initial_guess, _process_verbose_param, BVPVerbosity
 using SciMLBase: SciMLBase, BVProblem, TwoPointBVProblem, ReturnCode
+using SciMLLogging: @SciMLMessage
 using ODEInterface: OptionsODE, OPT_ATOL, OPT_RTOL, OPT_METHODCHOICE, OPT_DIAGNOSTICOUTPUT,
     OPT_ERRORCONTROL, OPT_SINGULARTERM, OPT_MAXSTEPS, OPT_BVPCLASS,
     OPT_SOLMETHOD, OPT_RHS_CALLMODE, OPT_COLLOCATIONPTS, OPT_ADDGRIDPOINTS,

lib/BoundaryValueDiffEqAscher/Project.toml

@@ -12,8 +12,6 @@ DifferentiationInterface = "a0c0ee7d-e4b9-4e03-894e-1c5f64a51d63"
 FastClosures = "9aa1b823-49e4-5ca5-8b0f-3971ec8bab6a"
 ForwardDiff = "f6369f11-7733-5829-9624-2563aa707210"
 LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
-PreallocationTools = "d236fae5-4411-538c-8e31-a6e3d9e00b46"
-RecursiveArrayTools = "731186ca-8d62-57ce-b412-fbd966d074cd"
 Reexport = "189a3867-3050-52da-a836-e630ba90ab69"
 SciMLBase = "0bca4576-84f4-4d90-8ffe-ffa030f20462"
 Setfield = "efcf1570-3423-57d1-acb7-fd33fddbac46"
@@ -29,11 +27,10 @@ DifferentiationInterface = "0.7.15"
 FastClosures = "0.3.2"
 ForwardDiff = "0.10.38, 1"
 LinearAlgebra = "1.10"
-PreallocationTools = "1.2"
 Random = "1.10"
 RecursiveArrayTools = "3.27.0, 4"
 Reexport = "1.2"
-SciMLBase = "3"
+SciMLBase = "3.30"
 SciMLTesting = "1"
 Setfield = "1.1.1"
 StaticArrays = "1.9.8"

lib/BoundaryValueDiffEqAscher/src/BoundaryValueDiffEqAscher.jl

@@ -3,26 +3,26 @@ module BoundaryValueDiffEqAscher
 using ADTypes: ADTypes, AutoSparse, AutoForwardDiff
 using AlmostBlockDiagonals: AlmostBlockDiagonals, IntermediateAlmostBlockDiagonal
 
-using BoundaryValueDiffEqCore: AbstractBoundaryValueDiffEqAlgorithm,
+using BoundaryValueDiffEqCore: BoundaryValueDiffEqCore,
+    AbstractBoundaryValueDiffEqAlgorithm,
     AbstractBoundaryValueDiffEqCache, BVPJacobianAlgorithm,
+    DEFAULT_VERBOSE, GlobalErrorControl, _process_verbose_param,
     __extract_problem_details, concrete_jacobian_algorithm,
-    __Fix3, __concrete_solve_algorithm,
-    __internal_nlsolve_problem, __vec, __vec_f, __vec_f!,
+    __concrete_solve_algorithm,
+    __vec, __vec_f, __vec_f!,
     __vec_bc, __vec_bc!, __extract_mesh, get_dense_ad,
     __get_bcresid_prototype, __split_kwargs, __concrete_kwargs,
     __default_nonsparse_ad, __construct_internal_problem,
     __internal_solve, __build_cost
 
 using ConcreteStructs: @concrete
-using DifferentiationInterface: DifferentiationInterface, Constant, prepare_jacobian
+using DifferentiationInterface: DifferentiationInterface, Constant
 using FastClosures: @closure
-using ForwardDiff: ForwardDiff, Dual
-using LinearAlgebra
-using PreallocationTools: PreallocationTools, DiffCache
-using RecursiveArrayTools: VectorOfArray, recursivecopy
+using ForwardDiff: ForwardDiff
+using LinearAlgebra: LinearAlgebra, I, norm, rank
 using Reexport: @reexport
-using SciMLBase: SciMLBase, AbstractDiffEqInterpolation, StandardBVProblem, __solve,
-    _unwrap_val
+using SciMLBase: SciMLBase, BVProblem, ReturnCode, StandardBVProblem,
+    TwoPointBVProblem, isinplace, solve
 using Setfield: @set!
 
 const DI = DifferentiationInterface

lib/BoundaryValueDiffEqAscher/test/qa/qa.jl

@@ -5,9 +5,12 @@ using Test
 run_qa(
     BoundaryValueDiffEqAscher;
     explicit_imports = true,
-    # Pre-existing ExplicitImports findings, tracked in SciML/BoundaryValueDiffEq.jl#519.
-    ei_broken = (
-        :no_implicit_imports, :no_stale_explicit_imports,
-        :all_qualified_accesses_are_public, :all_explicit_imports_are_public,
+    ei_kwargs = (;
+        # StandardBVProblem is a SciMLBase-owned BVP problem type that this solver
+        # legitimately dispatches on but which SciMLBase does not mark public.
+        all_explicit_imports_are_public = (; ignore = (:StandardBVProblem,)),
+        # ForwardDiff.Dual / ForwardDiff.jacobian! are ForwardDiff internals with
+        # no public replacement.
+        all_qualified_accesses_are_public = (; ignore = (:Dual, :jacobian!)),
     ),
 )

lib/BoundaryValueDiffEqCore/Project.toml

@@ -21,6 +21,7 @@ RecursiveArrayTools = "731186ca-8d62-57ce-b412-fbd966d074cd"
 Reexport = "189a3867-3050-52da-a836-e630ba90ab69"
 SciMLBase = "0bca4576-84f4-4d90-8ffe-ffa030f20462"
 SciMLLogging = "a6db7da4-7206-11f0-1eab-35f2a5dbe1d1"
+SciMLPublic = "431bcebd-1456-4ced-9d72-93c2757fff0b"
 SciMLStructures = "53ae85a6-f571-4167-b2af-e1d143709226"
 Setfield = "efcf1570-3423-57d1-acb7-fd33fddbac46"
 SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf"
@@ -44,8 +45,9 @@ OptimizationBase = "5.1"
 PreallocationTools = "1.2"
 RecursiveArrayTools = "3.27.0, 4"
 Reexport = "1.2"
-SciMLBase = "3"
+SciMLBase = "3.30"
 SciMLLogging = "1.10.1, 2"
+SciMLPublic = "1"
 SciMLTesting = "1"
 SciMLStructures = "1.7.0"
 Setfield = "1"

lib/BoundaryValueDiffEqCore/src/BoundaryValueDiffEqCore.jl

@@ -2,26 +2,31 @@ module BoundaryValueDiffEqCore
 
 using Adapt: adapt
 using ADTypes: ADTypes, AbstractADType, AutoSparse, AutoForwardDiff, AutoFiniteDiff,
-    NoSparsityDetector, KnownJacobianSparsityDetector, AutoPolyesterForwardDiff
-using ArrayInterface: parameterless_type, fast_scalar_indexing
+    AutoPolyesterForwardDiff
+using ArrayInterface: parameterless_type
 using ConcreteStructs: @concrete
 using DiffEqBase: DiffEqBase, solve
 using ForwardDiff: ForwardDiff, pickchunksize
 using Integrals: Integrals, IntegralProblem
-using LinearAlgebra
+using LinearAlgebra: LinearAlgebra, mul!
 using LineSearch: BackTracking
-using NonlinearSolveFirstOrder: NonlinearSolvePolyAlgorithm
+using NonlinearSolveFirstOrder: NonlinearSolveFirstOrder, NonlinearSolvePolyAlgorithm,
+    GaussNewton, LevenbergMarquardt, NewtonRaphson, NonlinearSolveBase, TrustRegion
 using NonlinearSolveBase: NonlinearVerbosity
 using OptimizationBase: OptimizationBase, OptimizationVerbosity
 using PreallocationTools: PreallocationTools, DiffCache, get_tmp
 using RecursiveArrayTools: AbstractVectorOfArray, VectorOfArray, DiffEqArray
 using Reexport: @reexport
-using SciMLBase: SciMLBase, AbstractBVProblem, AbstractDiffEqInterpolation,
-    StandardBVProblem, StandardSecondOrderBVProblem, __solve, _unwrap_val
-using SciMLLogging: SciMLLogging, @SciMLMessage, Silent, DebugLevel,
-    InfoLevel, WarnLevel, ErrorLevel, @verbosity_specifier, AbstractVerbositySpecifier,
+using SciMLBase: SciMLBase, AbstractBVProblem, BVProblem, NonlinearFunction,
+    NonlinearLeastSquaresProblem, NonlinearProblem, OptimizationFunction,
+    OptimizationProblem, SecondOrderBVProblem, StandardBVProblem,
+    StandardSecondOrderBVProblem, TwoPointBVProblem, TwoPointSecondOrderBVProblem,
+    __solve
+using SciMLLogging: SciMLLogging, Silent,
+    InfoLevel, WarnLevel, @verbosity_specifier,
     None, Minimal, Standard, Detailed, All
-using Setfield: @set!, @set
+using SciMLPublic: @public
+using Setfield: @set!
 using SparseArrays: sparse
 using SparseConnectivityTracer: SparseConnectivityTracer, TracerLocalSparsityDetector
 using SparseMatrixColorings: GreedyColoringAlgorithm
@@ -55,4 +60,28 @@ export HOErrorControl, REErrorControl
 export integral
 export BVPVerbosity, _process_verbose_param, DEFAULT_VERBOSE
 
+# Internal API consumed by the solver sublibraries (BoundaryValueDiffEqMIRK,
+# BoundaryValueDiffEqFIRK, BoundaryValueDiffEqShooting, BoundaryValueDiffEqAscher,
+# BoundaryValueDiffEqMIRKN). Marked public so the sublibraries can import these
+# without ExplicitImports flagging them; not exported because they are not part
+# of the user-facing API.
+@public AbstractBoundaryValueDiffEqCache, AbstractErrorControl, DiffCacheNeeded,
+    EvalSol, NoDiffCacheNeeded, __FastShortcutNonlinearPolyalg, __Fix3,
+    __add_singular_term!, __any_sparse_ad, __build_cost, __build_solution,
+    __cache_trait, __concrete_kwargs, __concrete_solve_algorithm,
+    __construct_internal_problem, __default_coloring_algorithm,
+    __default_nonsparse_ad, __default_sparse_ad, __default_sparsity_detector,
+    __extract_mesh, __extract_problem_details, __extract_u0,
+    __flatten_initial_guess, __get_bcresid_prototype, __get_non_sparse_ad,
+    __has_initial_guess, __initial_guess, __initial_guess_length,
+    __initial_guess_on_mesh, __internal_nlsolve_problem,
+    __internal_optimization_problem, __internal_solve,
+    __materialize_jacobian_algorithm, __maybe_allocate_diffcache, __maybe_matmul!,
+    __needs_diffcache, __resize!, __restructure_sol, __split_kwargs,
+    __tunable_part, __use_both_error_control, __vec, __vec_bc, __vec_bc!,
+    __vec_f, __vec_f!, __vec_so_bc, __vec_so_bc!, _sparse_like,
+    concrete_jacobian_algorithm, diff!, eval_bc_residual, eval_bc_residual!,
+    get_dense_ad, interval, nodual_value, recursive_flatten, recursive_flatten!,
+    recursive_flatten_twopoint!, recursive_unflatten!, safe_similar, _unwrap_val
+
 end

lib/BoundaryValueDiffEqCore/src/utils.jl

@@ -1,3 +1,6 @@
+_unwrap_val(::Val{B}) where {B} = B
+_unwrap_val(B) = B
+
 recursive_length(x::Vector{<:AbstractArray}) = sum(length, x)
 recursive_length(x::Vector{<:DiffCache}) = sum(xᵢ -> length(xᵢ.u), x)
 

lib/BoundaryValueDiffEqCore/test/qa/qa.jl

@@ -9,9 +9,29 @@ run_qa(
         ambiguities = (; recursive = false),
         stale_deps = (; ignore = [:TimerOutputs]),
     ),
-    # Pre-existing ExplicitImports findings, tracked in SciML/BoundaryValueDiffEq.jl#519.
-    ei_broken = (
-        :no_implicit_imports, :no_stale_explicit_imports,
-        :all_qualified_accesses_are_public, :all_explicit_imports_are_public,
+    ei_kwargs = (;
+        # All remaining entries are external internals with no public replacement:
+        #   - SciMLBase: BVP problem/algorithm abstract types that BVP solvers
+        #     legitimately subtype/extend, and solution_new_original_retcode (no
+        #     public counterpart; solution_new_retcode does not preserve the
+        #     original retcode).
+        #   - ForwardDiff Dual/value/can_dual/pickchunksize: not marked public.
+        #   - ArrayInterface.parameterless_type: not marked public.
+        #   - SciMLStructures Tunable/canonicalize/isscimlstructure/replace: the
+        #     SciMLStructures interface is not marked public.
+        #   - SparseConnectivityTracer Dual/primal: internal tracer types.
+        all_explicit_imports_are_public = (;
+            ignore = (
+                :AbstractBVProblem, :StandardBVProblem, :StandardSecondOrderBVProblem,
+                :parameterless_type, :pickchunksize,
+            ),
+        ),
+        all_qualified_accesses_are_public = (;
+            ignore = (
+                :AbstractBVPAlgorithm, :AbstractBVProblem, :solution_new_original_retcode,
+                :Dual, :value, :can_dual, :primal,
+                :Tunable, :canonicalize, :isscimlstructure, :replace,
+            ),
+        ),
     ),
 )

lib/BoundaryValueDiffEqFIRK/src/BoundaryValueDiffEqFIRK.jl

@@ -3,27 +3,27 @@ module BoundaryValueDiffEqFIRK
 using ADTypes: ADTypes, AutoSparse, AutoForwardDiff
 using ArrayInterface: fast_scalar_indexing
 using BandedMatrices: BandedMatrix, Ones
-using BoundaryValueDiffEqCore: AbstractBoundaryValueDiffEqAlgorithm,
+using BoundaryValueDiffEqCore: BoundaryValueDiffEqCore,
+    AbstractBoundaryValueDiffEqAlgorithm,
     AbstractBoundaryValueDiffEqCache, BVPJacobianAlgorithm,
-    recursive_flatten, recursive_flatten!, recursive_unflatten!,
+    DEFAULT_VERBOSE, DefectControl, GaussNewton, LevenbergMarquardt,
+    _process_verbose_param,
+    recursive_flatten!, recursive_unflatten!,
     __concrete_solve_algorithm, diff!, EvalSol,
     concrete_jacobian_algorithm, eval_bc_residual, interval,
-    eval_bc_residual!, get_tmp, __maybe_matmul!, __resize!,
-    __extract_problem_details, __initial_guess, nodual_value,
+    eval_bc_residual!, __maybe_matmul!, __resize!,
+    __extract_problem_details, nodual_value,
     __maybe_allocate_diffcache, __restructure_sol,
     __get_bcresid_prototype, __vec, __vec_f, __vec_f!, __vec_bc,
     __vec_bc!, recursive_flatten_twopoint!, __concrete_kwargs,
-    __internal_nlsolve_problem, __extract_mesh, __extract_u0,
-    __default_coloring_algorithm, __maybe_allocate_diffcache,
-    __restructure_sol, __get_bcresid_prototype, safe_similar,
-    __vec, __vec_f, __vec_f!, __vec_bc, __vec_bc!, __cache_trait,
-    recursive_flatten_twopoint!, __internal_nlsolve_problem,
-    __extract_mesh, __extract_u0, DiffCacheNeeded,
-    NoDiffCacheNeeded, __has_initial_guess,
-    __construct_internal_problem, __initial_guess_length,
-    __initial_guess_on_mesh, __flatten_initial_guess,
-    __build_solution, __Fix3, __split_kwargs, _sparse_like,
-    get_dense_ad, __internal_optimization_problem,
+    __extract_mesh,
+    __default_coloring_algorithm, safe_similar, __cache_trait,
+    DiffCacheNeeded,
+    NoDiffCacheNeeded,
+    __construct_internal_problem,
+    __initial_guess_on_mesh,
+    __build_solution, __split_kwargs, _sparse_like,
+    get_dense_ad,
     __internal_solve, __default_sparsity_detector, __build_cost,
     __tunable_part, __add_singular_term!
 
@@ -32,17 +32,18 @@ using DifferentiationInterface: DifferentiationInterface, Constant
 using FastAlmostBandedMatrices: AlmostBandedMatrix, fillpart, exclusive_bandpart,
     finish_part_setindex!
 using FastClosures: @closure
-using ForwardDiff: ForwardDiff, pickchunksize, Dual
-using LinearAlgebra
-using RecursiveArrayTools: AbstractVectorOfArray, AbstractVectorOfArray, DiffEqArray,
+using ForwardDiff: ForwardDiff, pickchunksize
+using LinearAlgebra: LinearAlgebra
+using RecursiveArrayTools: AbstractVectorOfArray, DiffEqArray,
     VectorOfArray, recursivecopy, recursivefill!
 using Reexport: @reexport
-using PreallocationTools: PreallocationTools, DiffCache
+using PreallocationTools: PreallocationTools, DiffCache, get_tmp
 using PrecompileTools: @compile_workload, @setup_workload
 using Preferences: Preferences
-using SciMLBase: SciMLBase, AbstractDiffEqInterpolation, StandardBVProblem, __solve,
-    _unwrap_val
-using Setfield: @set!, @set
+using SciMLBase: SciMLBase, AbstractDiffEqInterpolation, BVPFunction, BVProblem,
+    NonlinearProblem, ReturnCode, StandardBVProblem, TwoPointBVProblem,
+    __solve, isinplace, remake, solve
+using Setfield: @set!
 using SparseArrays: sparse
 using SciMLStructures: SciMLStructures
 using StaticArrays: SMatrix, SVector