QA: run_qa v1.6 form + ExplicitImports (root + sublibs) by ChrisRackauckas-Claude · Pull Request #3777 · SciML/OrdinaryDiffEq.jl

ChrisRackauckas-Claude · 2026-06-25T17:41:56Z

Ignore until reviewed by @ChrisRackauckas.

Converts every QA environment in the OrdinaryDiffEq.jl monorepo to the SciMLTesting 1.6 run_qa form and enables the ExplicitImports checks (explicit_imports = true). One feature branch, one PR.

What changed

Root test/qa/qa_tests.jl → run_qa(OrdinaryDiffEq; aqua = false, explicit_imports = true, ei_kwargs = ...). The umbrella lane historically ran only ExplicitImports (no Aqua/JET), so aqua = false preserves that scope. All six EI checks pass; the one public-API miss (init/solve/solve!/step! from CommonSolve, successful_retcode from SciMLBase) is handled with a small all_explicit_imports_are_public ignore-list. Root Project.toml: SciMLTesting compat → "1.6", ExplicitImports dropped from [extras]/[targets].test (now transitive via SciMLTesting).
47 sublibrary test/qa/qa.jl → run_qa(<Sublib>; ...):
- Aqua sub-check disables preserved verbatim as aqua_kwargs (e.g. piracies = false, unbound_args = false, deps_compat = (; check_extras = false)).
- Sublibraries whose old qa.jl ran JET inline (the StochasticDiffEq* and *Tableaus packages) keep JET via using JET + jet_kwargs = (; target_defined_modules = true). Solver sublibraries keep their separate test/qa/jet.jl (bespoke @test_opt type-stability tests) untouched — only the Aqua file is converted.
- explicit_imports = true on every env. Findings that depend on OrdinaryDiffEqCore/SciMLBase/DiffEqBase internal (non-public) API are recorded as ei_broken so the lane is green-or-broken with 0 hard EI failures (tracked in ExplicitImports: drive sublibrary QA checks to green (ei_broken markers) #3776; ei_broken auto-flags an Unexpected Pass once the upstream make-public work lands). OrdinaryDiffEqRosenbrockTableaus and StochasticDiffEqLevyArea pass all six checks (no ei_broken).
- Each sublib test/qa/Project.toml gains SciMLTesting = "1.6"; [sources] / develop wiring is left exactly as-is.
DelayDiffEq (test/qa/qa_tests.jl, runs in the main test env): converted to run_qa preserving its bespoke Aqua config (ambiguities = (; recursive = false), piracies = (; treat_as_own = [...])) and its existing EI ignore-lists; the three new public-API/owner checks recorded as ei_broken. Main Project.toml: +SciMLTesting, -ExplicitImports.
Genuine fixes folded in (FIX > IGNORE > BROKEN):
- StochasticDiffEqLevyArea: removed stale using Random: Xoshiro (unused in the module) so no_stale_explicit_imports passes cleanly.
- OrdinaryDiffEqCore: removed the now-unused DataStructures dependency (replaced by BinaryHeaps.jl in Replace DataStructures.jl with BinaryHeaps.jl to cut invalidations #3407 but left in [deps]/[compat]), which Aqua stale_deps flags.

Verified locally (released SciMLTesting 1.6.0)

env	result
root `OrdinaryDiffEq`	QA 6/6 pass, 0 broken, 0 fail
`StochasticDiffEqLevyArea` (Family A, clean)	QA 18/18 pass, 0 broken, 0 fail
`OrdinaryDiffEqTsit5` (Family B + ei_broken)	QA 13 pass / 4 broken / 0 fail
`OrdinaryDiffEqCore` (after DataStructures fix)	Aqua passes, 6 EI broken, 0 fail

CI covers the remaining sublibraries.

Pre-existing failures (NOT introduced here)

StochasticDiffEqImplicit's QA has pre-existing Aqua undefined_exports and JET nlsolve!/get_W dispatch failures. These reproduce byte-for-byte with the unmodified master qa.jl (Aqua.test_all + JET.test_package(...; target_defined_modules = true)), so this conversion preserves — does not introduce — them. They are real package bugs to be tracked/fixed separately and are intentionally left as hard failures rather than silently suppressed.

🤖 Generated with Claude Code

Convert every QA environment in the monorepo to SciMLTesting 1.6 `run_qa` and enable the ExplicitImports checks. - root test/qa/qa_tests.jl -> run_qa(OrdinaryDiffEq; aqua = false, explicit_imports = true, ...); preserves the umbrella's EI-only scope and adds a small all_explicit_imports_are_public ignore-list. SciMLTesting compat -> "1.6", ExplicitImports dropped (transitive). - 47 sublibrary test/qa/qa.jl -> run_qa(<Sublib>; ...). Aqua sub-check disables preserved as aqua_kwargs. StochasticDiffEq*/`*Tableaus` keep JET inline via `using JET` + jet_kwargs = (; target_defined_modules = true); solver sublibs keep their separate jet.jl. explicit_imports = true on every env, with internal-API findings recorded as ei_broken (0 hard EI failures; tracked in SciML#3776; auto-flags once upstream make-public lands). - DelayDiffEq test/qa/qa_tests.jl -> run_qa preserving its treat_as_own piracy and recursive=false ambiguities config and EI ignore-lists. - Each test/qa/Project.toml gains SciMLTesting = "1.6"; [sources]/develop wiring untouched. Fixes folded in (FIX > IGNORE > BROKEN): - StochasticDiffEqLevyArea: drop stale `using Random: Xoshiro`. - OrdinaryDiffEqCore: drop unused DataStructures dep (replaced by BinaryHeaps in SciML#3407, left in [deps]/[compat]); Aqua stale_deps now passes. Verified locally vs released SciMLTesting 1.6.0: root 6/6 pass; StochasticDiffEqLevyArea 18/18 pass; OrdinaryDiffEqTsit5 13 pass/4 broken; OrdinaryDiffEqCore 9 pass/6 broken; all 0 hard fail. Co-Authored-By: Chris Rackauckas <accounts@chrisrackauckas.com> Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

SciMLTesting 1.7.0 runs the two public-API ExplicitImports checks (check_all_qualified_accesses_are_public, check_all_explicit_imports_are_public) only on Julia >= 1.11, and the base-lib make-public releases (CommonSolve 0.2.9 made init/solve/solve!/ step! public; SciMLBase 3.24.0 made successful_retcode public) now declare the umbrella's re-exported entrypoints public. With both, the umbrella OrdinaryDiffEq passes all_explicit_imports_are_public with an empty ignore-list, so the per-name ignore list is dead weight. Verified against the registered releases (no dev) on Julia 1.12: the umbrella passes both public-API checks. On 1.10 the public-API checks are skipped by SciMLTesting 1.7, so the emptied list is inert there. The per-sublib ei_broken public-API markers are NOT redundant and are left untouched: every OrdinaryDiffEq/StochasticDiffEq sublib still imports non-public internals from OrdinaryDiffEqCore / sibling sublibs / DiffEqBase / SciMLBase / NonlinearSolveBase (verified: all 45 sublib QA envs still fail the public-API check(s) they mark broken on 1.12 against registered releases), tracked under SciML#3776. Co-Authored-By: Chris Rackauckas <accounts@chrisrackauckas.com> Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

…Base make-public Now that SciMLBase 3.27.0 and the lib/DiffEqBase make-public work (SciML#3785) are in place, complete the ExplicitImports public-API cleanup on top of the run_qa conversion: - Caller migration: rewrite `DiffEqBase.X` -> `SciMLBase.X` for the SciMLBase-owned, now-public names accessed qualified in sublibrary source: * `AbstractSDEProblem` across the StochasticDiffEq* solver sublibs (alg_utils/solve), * `build_solution` in DiffEqDevTools (add `import SciMLBase`), * `isinplace` in DelayDiffEq. `AbstractRODEProblem` is NOT public in SciMLBase 3.27, so it correctly stays `DiffEqBase.AbstractRODEProblem`. - Declare DiffEqBase-owned `ImplicitRKTableau` public (sibling of the already-public `ExplicitRKTableau` from SciML#3785; documented API used downstream via `DiffEqBase.ImplicitRKTableau`). - Reconcile every sublibrary `ei_broken` against the actual ExplicitImports result on Julia 1.12 with the released versions (0 unexpected passes, 0 hard failures): * OrdinaryDiffEqExplicitTableaus / OrdinaryDiffEqImplicitTableaus now pass all six checks (drop `ei_broken` entirely), * StochasticDiffEqRODE / StochasticDiffEqIIF: `all_qualified_accesses_are_public` now passes after the AbstractSDEProblem migration (drop it), * StochasticDiffEqHighOrder/LowOrder/Milstein/ROCK/Weak: `all_qualified_accesses_via_owners` now passes after the migration (drop it). The remaining `ei_broken` entries are genuine not-yet-public OrdinaryDiffEqCore / StochasticDiffEqCore / DiffEqBase-internal survivors (e.g. `@cache`, `perform_step!`, `is_diagonal_noise`), tracked in SciML#3776 — left as known-broken, not silenced. - Bump `SciMLTesting` compat `"1.6"` -> `"1.7"` in every QA env + root + DelayDiffEq: 1.7 gates the two public-API checks to Julia >= 1.11 so the LTS lane skips them. Verified locally against the registered releases: root QA 6/6 on 1.12; DelayDiffEq 14 pass / 3 broken / 0 fail on 1.12; Tableaus 16/16 on 1.10; all sublibrary ei_broken sets match the live ExplicitImports result on 1.12. Co-Authored-By: Chris Rackauckas <accounts@chrisrackauckas.com> Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

@def

Migrate the DiffEqDevTools module imports to their public owners and convert the run_qa explicit-imports blanket `ei_broken` (all 6 checks) into narrow, documented `ei_kwargs` ignore lists. - Make implicit imports explicit (SciMLBase/CommonSolve/RootedTrees/Statistics/ RecipesBase/RecursiveArrayTools/StructArrays/DiffEqNoiseProcess/NLsolve). - Import SciMLBase-owned abstract types and `has_analytic` from SciMLBase (their owner; public in SciMLBase 3.30), fixing the via_owners checks; qualify `allowedkeywords`/`calculate_ensemble_errors`/`has_analytic` through SciMLBase. - Drop stale `AbstractDDEProblem` import; import `residual_order_condition` explicitly from RootedTrees (re-exported + extended here). - Add CommonSolve dep (init/solve/step!), bump SciMLBase compat floor to 3.30. 4 of 6 EI checks now pass with zero exceptions. The 2 residual ignore lists cover only names that are still non-public upstream: SciMLBase-owned allowedkeywords/calculate_ensemble_errors and the AbstractDDEAlgorithm/ AbstractODESolution/AbstractRODEProblem/AbstractSDDEProblem/AbstractBVProblem/ @def abstracts, plus DiffEqBase-only ConvergenceSetup/ODERKTableau. Co-Authored-By: Chris Rackauckas <accounts@chrisrackauckas.com>

Replace the blanket ei_broken=(5 checks) with tight, documented per-name ignore lists, and clean up the module imports: - Import alg_order from its owner SciMLBase (now public). - Import calculate_residuals/calculate_residuals!/initialize! from their owner DiffEqBase (initialize! is public) and copyat_or_push! from its owner RecursiveArrayTools (public) instead of routing through OrdinaryDiffEqCore (fixes all_explicit_imports_via_owners / all_qualified_accesses_via_owners). - Drop the bare `using DiffEqBase` and the stale `@def`/`uses_uprev` imports; make the remaining DiffEqBase imports explicit. Residual ignores are limited to genuinely non-public upstream names (OrdinaryDiffEqCore solver-extension API + DiffEqBase residual helpers, tracked in SciML#3776), the unavoidable `@reexport using SciMLBase` implicit bindings, and the ExplicitImports macro-blindness false stale for @tight_loop_macros. Co-Authored-By: Chris Rackauckas <accounts@chrisrackauckas.com>

Migrate now-public/owned names to their owners and remove blanket ei_broken: - alg_order: import from SciMLBase (owner, public) - initialize!: import from DiffEqBase (owner, public) - calculate_residuals/calculate_residuals!: import from DiffEqBase (owner) - make @muladd / @.. / @reexport / SciMLBase explicit (no_implicit_imports) - remove stale imports @SciMLMessage / _ad_chunksize_int / _ad_fdtype / _fixup_ad 4 of 5 previously ei_broken checks now pass. The residual non-public names (OrdinaryDiffEqCore solver-interface internals, DiffEqBase residual helpers, OrdinaryDiffEqLowOrderRK starter caches) are narrowed to tight documented ignores in qa.jl instead of a blanket ei_broken. See SciML#3776. Co-Authored-By: Chris Rackauckas <accounts@chrisrackauckas.com>

@def

Convert the blanket ei_broken (5 checks) to migration + tight ignores: - Migrate now-public names to public owners: alg_order -> SciMLBase, initialize! -> DiffEqBase. - Route owner-correct DiffEqBase names through DiffEqBase: calculate_residuals, calculate_residuals!. - Make exported-name implicit imports explicit: @.. (FastBroadcast), @muladd (MuladdMacro), recursivefill! (RecursiveArrayTools), @reexport (Reexport). - Drop stale imports: OrdinaryDiffEqAlgorithm, Serial, unwrap_alg, uses_uprev, isfsal, _vec, _reshape, _unwrap_val, @def, _ode_interpolant!, _ode_addsteps!. Remaining exceptions are tight, documented ignores for genuinely non-public internals: - no_implicit_imports: SciMLBase (deliberate @reexport surface). - all_qualified_accesses_are_public: increment_nf!, set_EEst! (OrdinaryDiffEqCore solver-interface internals). - all_explicit_imports_are_public: OrdinaryDiffEqCore solver internals (@cache, CompiledFloats, OrdinaryDiffEqAdaptiveAlgorithm, OrdinaryDiffEqConstantCache, OrdinaryDiffEqMutableCache, alg_cache, constvalue, generic_solver_docstring, get_fsalfirstlast, perform_step!, trivial_limiter!) plus DiffEqBase internals (@tight_loop_macros, calculate_residuals, calculate_residuals!). QA EI green on Julia 1.12 (17/17). Co-Authored-By: Chris Rackauckas <accounts@chrisrackauckas.com>

Drop the blanket ei_broken tuple and instead fix the underlying ExplicitImports findings on SciMLBase 3.30 / OrdinaryDiffEqCore 4.4: - make implicit imports explicit (DiffEqBase, SciMLBase, Reexport) - remove stale FastBroadcast.Serial import - import alg_order from its owner SciMLBase (now public) and initialize! from its owner DiffEqBase (now public) - access DISCRETE_{IN,OUT}OFPLACE_DEFAULT via owner SciMLBase Remaining residue is genuinely OrdinaryDiffEqCore/DiffEqBase/SciMLBase internal (non-public) solver hooks with no public alternative; these are narrowed to tight documented ignore lists in qa.jl rather than a blanket broken-check. See SciML#3776. Co-Authored-By: Chris Rackauckas <accounts@chrisrackauckas.com>

Replace the blanket ei_broken=(5 checks) in test/qa/qa.jl with tight, documented ignore lists for only the genuinely-non-public names. src changes (eliminate, not suppress): - Make implicit imports explicit (SciMLBase, Reexport/@reexport). - Remove stale import uses_uprev. - Re-route owner-mismatched names to their owner module: alg_order/@def/ _unwrap_val -> SciMLBase; copyat_or_push! -> RecursiveArrayTools; initialize!/calculate_residuals/calculate_residuals! -> DiffEqBase. alg_order, copyat_or_push! and initialize! are public on their owners, so this also clears them from the public-API checks. Now-green: no_implicit_imports, no_stale_explicit_imports, all_explicit_imports_via_owners. The two public-API checks retain tight ignores for OrdinaryDiffEqCore/DiffEqBase/SciMLBase solver internals with no public alternative (tracked for make-public in SciML#3776). Co-Authored-By: Chris Rackauckas <accounts@chrisrackauckas.com>

…ken) Replace the 4 blanket ei_broken checks with real import fixes plus tight, documented per-name ignores of only genuinely-internal names. Fixed (no longer suppressed): - no_implicit_imports: explicit `using`/`import` of @.., @muladd, recursivefill!, @reexport, and the SciMLBase/DiffEqBase module names used in qualified accesses. - all_explicit_imports_via_owners: import alg_order from SciMLBase (now public), initialize! + calculate_residuals(!) from DiffEqBase (their Base.which owner), copyat_or_push! from RecursiveArrayTools (now public). - no_stale_explicit_imports: removed unused `full_cache` import. Residual ignores are exactly the OrdinaryDiffEqCore/DiffEqBase/Base-internal extension points with no public alternative (tracked for make-public in SciML#3776). Co-Authored-By: Chris Rackauckas <accounts@chrisrackauckas.com>

Drop blanket ei_broken (5 checks) for tight documented ignore lists. Make implicit imports explicit, remove stale imports, and import now-public names from their true public owners (alg_order<-SciMLBase, initialize!<-DiffEqBase). Residual ignores are non-public internals of OrdinaryDiffEqCore/DiffEqBase/Base only (see SciML#3776). Co-Authored-By: Chris Rackauckas <accounts@chrisrackauckas.com>

Replace the blanket 5-check `ei_broken` in lib/ImplicitDiscreteSolve QA with real EI fixes plus tight, documented per-name ignore lists for the residual non-public internals. - Import public names from their owners: SciMLBase (alg_order, isadaptive, OverrideInit, problem/function types, ReturnCode, isinplace), DiffEqBase (DefaultInit, initialize!), CommonSolve (init, solve, step!), NonlinearSolveFirstOrder (NewtonRaphson). Make formerly-implicit exported names explicit; drop stale imports (@.., @muladd, BrownFullBasicInit, OrdinaryDiffEqConstantCache, _unwrap_val, parameter_symbols). - Add CommonSolve as a direct dep (init/solve/step! owner). - Remaining ignores are genuine OrdinaryDiffEqCore solver-interface internals (alg_cache/perform_step!/controller generics/abstract cache+controller types) and NonlinearSolveBase/SciMLBase non-public accessors, tracked for make-public in SciML#3776. All 6 ExplicitImports checks now pass; QA group 16/16 on Julia 1.12 against released SciMLTesting 1.7.0 / SciMLBase 3.30.0. Co-Authored-By: Chris Rackauckas <accounts@chrisrackauckas.com>

Convert blanket ei_broken (5 checks) to targeted source fixes plus tight documented ignore lists: - Import alg_order from SciMLBase and initialize! from DiffEqBase (now public in their owner modules) instead of OrdinaryDiffEqCore re-exports. - Import _vec from SciMLBase and calculate_residuals! from DiffEqBase (their owners) to satisfy all_explicit_imports_via_owners. - Remove stale OrdinaryDiffEqExponentialAlgorithm import. - Make implicit imports explicit (ExponentialUtilities, RecursiveArrayTools, SciMLOperators update_coefficients(!), SciMLBase SplitFunction, Reexport). - Residual non-public upstream internals are tightly listed in all_explicit_imports_are_public / all_qualified_accesses_are_public ignore lists with per-name documentation (no blanket ei_broken). QA EI green on Julia 1.12 (17/17), package still solves (LieEuler, MagnusGauss4 -> Success). Co-Authored-By: Chris Rackauckas <accounts@chrisrackauckas.com>

Replace the blanket 5-check ei_broken with targeted fixes plus tight, documented per-check ignore lists for genuinely-internal non-public names: - Import alg_order and _unwrap_val from their owner SciMLBase (alg_order is public there); import initialize! from its owner DiffEqBase (public). - Drop stale imports: @SciMLMessage, _ad_chunksize_int, _ad_fdtype (ADTypes AbstractADType), and dolinsolve (OrdinaryDiffEqDifferentiation). - Make FastBroadcast (@..) and Reexport (@reexport) explicit imports. - Ignore only SciMLBase (intended @reexport implicit), increment_nf! (OrdinaryDiffEqCore-internal), and the OrdinaryDiffEqCore / OrdinaryDiffEqNonlinearSolve / SciMLBase internal solver building blocks that are not yet declared public. Verified GROUP=QA run_qa on Julia 1.12: Quality Assurance 17/17 pass. Co-Authored-By: Chris Rackauckas <accounts@chrisrackauckas.com>

Drop the blanket 5-entry `ei_broken` in lib/OrdinaryDiffEqExtrapolation/test/qa/qa.jl. All four non-public checks besides the two public-API ones now pass cleanly: - no_implicit_imports: make implicit imports explicit (FastBroadcast/@.., MuladdMacro/@muladd, RecursiveArrayTools/recursivefill!, LinearSolve/RFLUFactorization, Reexport/@reexport, SciMLBase/LinearProblem+init, SciMLOperators/WOperator, SciMLLogging/@SciMLMessage). - no_stale_explicit_imports: remove unused imports (AbstractADType, BaseThreads, Minimal, Sequential, _ad_chunksize_int, _ad_fdtype, _digest_beta1_beta2, isadaptive, qmax_default). - all_explicit_imports_via_owners: import names from their true owner module (alg_order/_unwrap_val/_reshape/_vec/the Time*/U*Wrapper types from SciMLBase; initialize!/calculate_residuals[!]/timedepentdtmin from DiffEqBase; WOperator from SciMLOperators; @SciMLMessage from SciMLLogging). Add SciMLLogging and SciMLOperators as direct deps + compat. The remaining exceptions are genuinely-internal (non-`public`) upstream names with no public replacement yet, narrowed to two tight documented `ignore` lists on the public-API checks only. Co-Authored-By: Chris Rackauckas <accounts@chrisrackauckas.com>

Replace the blanket `ei_broken` suppression of all five ExplicitImports checks with concrete, documented per-check ignore lists, and fix the import header so the now-resolvable findings disappear: - Remove 38 stale (unused) explicit imports. - Import `_vec`, `_unwrap_val`, `UDerivativeWrapper`, `UJacobianWrapper` from their owner SciMLBase (OrdinaryDiffEqCore/DiffEqBase only re-export them), satisfying `all_explicit_imports_via_owners` for those names. - Tighten the residual ignores to exactly the genuinely non-public / non-owner re-exported names this sublibrary relies on (OrdinaryDiffEqCore solver internals, SciMLBase Jacobian-interface predicates, LinearSolve / ForwardDiff / DifferentiationInterface internals, the sublib's own sparse-extension API, and the Accessors `@set` / SciMLLogging `@SciMLMessage` macros). All six EI checks now run hard (no `ei_broken`). Verified GROUP=QA on Julia 1.12 against released SciMLTesting 1.7.0: Quality Assurance 15/15. Co-Authored-By: Chris Rackauckas <accounts@chrisrackauckas.com>

Make implicit imports explicit (FastBroadcast/@.., MuladdMacro/@muladd, Reexport/@reexport, SciMLBase), import alg_order from SciMLBase and initialize!/calculate_residuals[!] from their DiffEqBase owner, and drop the stale full_cache import. Replace the blanket ei_broken with tight, documented ignore lists for the residual OrdinaryDiffEqCore solver-interface internals and DiffEqBase residual helpers that are not yet public. Co-Authored-By: Chris Rackauckas <accounts@chrisrackauckas.com>

Migrate now-public names to their public owners and drop the blanket ei_broken for the three EI checks: - import alg_order and full_cache from SciMLBase (public owners) - import initialize! from DiffEqBase (public owner) - make Reexport/@reexport and the SciMLBase module reference explicit so no_implicit_imports passes The remaining all_explicit_imports_are_public failures are exactly the twelve OrdinaryDiffEqCore solver-interface names with no public owner on the registered releases; narrowed to a tight documented ignore list (tracked for make-public in SciML#3776) instead of a blanket ei_broken. ExplicitImports now reports 6/6 checks passing. Co-Authored-By: Chris Rackauckas <accounts@chrisrackauckas.com>

@def

Replace the blanket ei_broken (5 checks) with targeted fixes plus tight, documented public-API ignores: - Remove 9 stale explicit imports (_vec, _reshape, _unwrap_val, trivial_limiter!, unwrap_alg, uses_uprev, isfsal, _ode_addsteps!, OrdinaryDiffEqAdaptiveAlgorithm) — none are used in src. - Import names from their owning modules: alg_order from SciMLBase (now public there), initialize!/calculate_residuals/calculate_residuals! and @tight_loop_macros from DiffEqBase, @def from SciMLBase. - Make previously-implicit imports explicit: FastBroadcast @.., MuladdMacro @muladd, RecursiveArrayTools ArrayPartition/recursivefill!, Reexport @reexport, and the SciMLBase module binding. no_implicit_imports, no_stale_explicit_imports, and all_explicit_imports_via_owners now pass with no exceptions. The only remaining ignores are genuinely internal (non-public) solver-stack names with no public alias yet (OrdinaryDiffEqCore extension internals, DiffEqBase residual interface + @tight_loop_macros, SciMLBase @def); tracked for make-public in SciML#3776. Co-Authored-By: Chris Rackauckas <accounts@chrisrackauckas.com>

Replace the blanket 5-check `ei_broken` with elimination plus tight, documented per-check ignores: - Import `alg_order` from its owner SciMLBase (public there) and `initialize!`/`calculate_residuals`/`calculate_residuals!` from their owner DiffEqBase, satisfying `all_explicit_imports_via_owners`. - Make the FastBroadcast/MuladdMacro/RecursiveArrayTools implicit imports explicit (`@..`, `@muladd`, `recursivefill!`, `Serial`). - Drop the stale `DummyController` import; un-qualify every `OrdinaryDiffEqCore.<name>` access (method-extension targets and `get_EEst`/`set_EEst!`/`increment_nf!`) so `all_qualified_accesses_are_public` passes clean. The only remaining exceptions are tight documented ignores for the OrdinaryDiffEqCore solver-interface internals, the DiffEqBase residual primitives, and the OrdinaryDiffEqTsit5 first-step caches a Nordsieck solver must consume (`all_explicit_imports_are_public`), and the `@reexport using SciMLBase` idiom (`no_implicit_imports`). The other four EI checks pass with no ignore. Verified GROUP=QA on Julia 1.12: 17/17. Co-Authored-By: Chris Rackauckas <accounts@chrisrackauckas.com>

Eliminate the blanket ei_broken on all 5 ExplicitImports checks for OrdinaryDiffEqExponentialRK: - Make the 22 implicit imports explicit (ExponentialUtilities, FastBroadcast, MuladdMacro, RecursiveArrayTools, Reexport, SciMLBase/SplitFunction). - Remove 5 stale imports (AbstractADType, CompositeAlgorithm, _ad_chunksize_int, _ad_fdtype, the now-qualified-only DiffEqBase.prepare_alg import). - Route now-public / owner-correct names to their owners: alg_order from SciMLBase, initialize! from DiffEqBase; this clears the via-owners check. - Narrow the residual genuinely-internal names to a tight, documented per-name ignore (OrdinaryDiffEqCore / SciMLBase / DiffEqBase / OrdinaryDiffEqDifferentiation internals) instead of an opaque ei_broken over whole checks. QA group passes 17/17 on Julia 1.12 with only the tight ignores remaining. Co-Authored-By: Chris Rackauckas <accounts@chrisrackauckas.com>

Drop the blanket ei_broken (no_implicit_imports, no_stale_explicit_imports, all_explicit_imports_via_owners, all_explicit_imports_are_public) and fix at the source: - make Reexport/@reexport/SciMLBase explicit (no_implicit_imports) - remove stale imports uses_uprev, _ad_chunksize_int, _ad_fdtype, AbstractADType, and dolinsolve (no_stale_explicit_imports) - import alg_order/_unwrap_val from their owner SciMLBase and initialize! from its owner DiffEqBase (all_explicit_imports_via_owners); alg_order and initialize! are public on the owner module so they also clear all_explicit_imports_are_public Remaining all_explicit_imports_are_public exceptions are a tight, documented ignore of solver-internal names with no public alternative on the registered releases (OrdinaryDiffEqCore/OrdinaryDiffEqNonlinearSolve internals plus SciMLBase._unwrap_val); tracked for make-public in SciML#3776. Co-Authored-By: Chris Rackauckas <accounts@chrisrackauckas.com>

Replace the blanket 5-check ei_broken with explicit imports from owner modules and tight, documented ignore lists for the names that remain genuinely internal (no public counterpart in OrdinaryDiffEqCore / DiffEqBase / SciMLBase). - no_implicit_imports: make all implicit names explicit (@.., @muladd, recursivefill!, @reexport, ODEProblem, solve, and the SciMLBase module qualifier itself). - no_stale_explicit_imports: drop 7 unused imports (OrdinaryDiffEqNewton/RosenbrockAdaptiveAlgorithm, _vec, _reshape, _unwrap_val, unwrap_alg, uses_uprev). - all_*_via_owners: import from the owning module (alg_order <- SciMLBase; initialize!/calculate_residuals[!] <- DiffEqBase; copyat_or_push! <- RecursiveArrayTools). - Remaining non-public names are solver internals -> tight per-check ignore lists, not blanket ei_broken. See SciML#3776. Co-Authored-By: Chris Rackauckas <accounts@chrisrackauckas.com>

Drop the blanket ei_broken on all five ExplicitImports checks. Remove stale imports, make implicit imports explicit, import alg_order from its public owner SciMLBase, initialize! from DiffEqBase, and the FastBroadcast/MuladdMacro/ RecursiveArrayTools macros/names explicitly. The only remaining exceptions are tight documented ignores for OrdinaryDiffEqCore-internal (non-public) names the solver genuinely needs, tracked for make-public in SciML#3776. Co-Authored-By: Chris Rackauckas <accounts@chrisrackauckas.com>

@def

Replace the blanket `ei_broken` over all six ExplicitImports checks with live checks plus tight, individually documented ignore lists. Source fixes (eliminate, not ignore): - Add explicit `using SciMLBase: ...` for the 21 names previously relied on implicitly through `@reexport using SciMLBase`; explicit `using SciMLOperators` and `using CommonSolve: solve` (CommonSolve added to deps/compat as the owner of `solve`). - Import `resize!` from its owner `Base` and `check_error!` from its owner SciMLBase (both verified identical to the DiffEqBase/SciMLBase bindings). - Migrate `initialize_dae!` and `value` qualified accesses from DiffEqBase to their owner SciMLBase; `initialize_dae!` is public there so it is fully clean. - Drop genuinely-unused imports (rank, issingular, chain, recursivefill!, isautodifferentiable, DEIntegrator, get_tstops_max, @def, @tight_loop_macros, AbstractADType, the unused SciMLLogging level names, the SciMLOperators abstract types, etc.) and the now-unused ConcreteStructs dependency. Re-export contract preserved: - BrownFullBasicInit, ShampineCollocationInit, DEVerbosity, Minimal, _vec, _reshape, unwrap_cache, calculate_residuals, calculate_residuals! are unused by this package but imported into its namespace and re-imported by dependent OrdinaryDiffEq.jl sublibraries; kept and documented, with matching `no_stale_explicit_imports` ignores that ExplicitImports cannot infer cross-package. Residual ignores are upstream-internal (non-`public`) names with no public replacement, documented per source module. `OrdinaryDiffEqCore.Predictor` (a generated EnumX submodule) is marked `allow_unanalyzable`. Verified on Julia 1.12 against released SciMLTesting 1.7.0 / SciMLBase 3.30.0: QA 15/15 pass (Aqua + all six EI checks run live, 0 fail/error/broken). Smoke solves with Tsit5, Rosenbrock23, and QNDF (BDF) all return Success. Co-Authored-By: Chris Rackauckas <accounts@chrisrackauckas.com>

@def

Convert the blanket ei_broken in the QA suite to tight, documented ignore lists. Fixes the source so the previously-broken checks pass: - no_implicit_imports / via_owners: import alg_order from its owner SciMLBase, calculate_residuals(!)/initialize! from DiffEqBase, copyat_or_push! from RecursiveArrayTools, and make Reexport/@reexport, SciMLBase/ODEProblem and solve (CommonSolve) explicit. Adds CommonSolve as a direct dependency. - The residual non-public names (OrdinaryDiffEqCore internals, DiffEqBase residual helpers, SciMLBase @def, TruncatedStacktraces macro, and the precompile-workload specialization markers / lorenz helpers) are listed as tight per-source ignores rather than a blanket ei_broken; tracked for make-public in SciML#3776. Verified on Julia 1.12 (SciMLTesting 1.7.0, SciMLBase 3.30.0): QA EI suite 17/17 pass, 0 fail/error/broken. Co-Authored-By: Chris Rackauckas <accounts@chrisrackauckas.com>

Replace the blanket six-check ei_broken with targeted fixes plus tight, documented ignore lists: - no_implicit_imports / no_stale_explicit_imports now PASS: bare `using` statements made explicit, and 9 unused imports removed (@capture, Diagonal, _ad_chunksize_int, _ad_fdtype, calc_W, diag, diagm, lu!, namify). - Migrated now-public names to their public owners: alg_order from SciMLBase (imported so methods can be extended), UniformScaling from LinearAlgebra. - The remaining residual is genuinely-internal cross-package solver-interface names from OrdinaryDiffEqCore / OrdinaryDiffEqDifferentiation (plus a few DiffEqBase / SciMLBase / Base internals) with no public home; these are now listed explicitly per-check via ei_kwargs ignore lists instead of a blanket ei_broken, so any name later made public surfaces as an Unexpected Pass. Verified GROUP=QA on Julia 1.12 against released SciMLTesting 1.7.0: Quality Assurance 17/17 pass, 0 fail/error/broken/unexpected-pass. Co-Authored-By: Chris Rackauckas <accounts@chrisrackauckas.com>

Drop stale ExplicitImports ignores that became public on this branch (OrdinaryDiffEqCore round-2 make-public: isdiscretecache, isdiscretealg, _initialize_dae!, allows_null_u0, resolve_basic). The all_explicit_imports_are_public list is now empty (all four names public), so it is removed entirely. The all_qualified_accesses_are_public list is trimmed to the genuine residual: _resolved_QT (OrdinaryDiffEqCore owner-internal, deliberately non-public) plus external non-public names from NonlinearSolveBase (get_fu/get_u/not_terminated/ update_from_termination_cache!/update_trace!) and SciMLBase (has_initializeprob). Co-Authored-By: Chris Rackauckas <accounts@chrisrackauckas.com>

@def

The base packages now declare their solver-author API public on this branch (PHASE A), and SciMLBase's round-5 abstract problem/solution/algorithm types (AbstractBVProblem/AbstractRODEProblem/AbstractSDDEProblem/AbstractDDEAlgorithm/ AbstractODESolution) are public in the resolved SciMLBase 3.30.1. DiffEqBase's ConvergenceSetup/ODERKTableau are likewise public on the in-repo copy. Drop those 7 now-public names from the ExplicitImports ignore lists, leaving only the genuine SciMLBase-owned-but-not-public residual: allowedkeywords and calculate_ensemble_errors (qualified accesses) and @def (explicit import). Verified on Julia 1.12 against the in-repo lib/* [sources]: run_qa EI green (6/6, 0 flagged). Co-Authored-By: Chris Rackauckas <accounts@chrisrackauckas.com>

Later OrdinaryDiffEqCore public-API commits on this branch now cover the three solver-internal hooks (_ode_interpolant!/isdiscretealg/isdiscretecache) that the prior pass still ignored under all_explicit_imports_are_public, so drop that whole block. The only genuine residual is the two SciMLBase-owned non-public default-solve sentinels (DISCRETE_INPLACE_DEFAULT/DISCRETE_OUTOFPLACE_DEFAULT). Verified green: run_qa ExplicitImports 6/6 on Julia 1.12. Co-Authored-By: Chris Rackauckas <accounts@chrisrackauckas.com>

@nif

…blic decls The OrdinaryDiffEqCore round-2 make-public sweep (cc11e02) declared DerivativeOrderNotPossibleError, _ode_interpolant!, hermite_interpolant!, and interpolation_differential_vars `public`, so they no longer need to be ignored in the ExplicitImports public-API checks. Trimmed the ignore lists from 7 to 3 entries. The empty-ignore probe on Julia 1.12 (native [sources] developing the on-branch lib/OrdinaryDiffEqCore + lib/DiffEqBase) flags only three genuine externals, which are kept: - @truncate_stacktrace (TruncatedStacktraces) - @nexprs, @nif (Base.Cartesian codegen macros) Verified on Julia 1.12: run_qa ExplicitImports 6/6 pass, 0 flagged. Co-Authored-By: Chris Rackauckas <accounts@chrisrackauckas.com>

SciMLBase 3.30.1 declares DECache public, so the qualified access SciMLBase.DECache no longer needs an all_qualified_accesses_are_public ignore entry. Verified on Julia 1.12 against the on-branch lib/* sources (DiffEqBase in-repo, SciMLBase 3.30.1 registry): run_qa passes 15/15 with the tightened list. Remaining residual is genuine (still-non-public SciMLBase internals, EnzymeCore/SciMLOperators/FastPower/FunctionWrappers/ TruncatedStacktraces/ConstructionBase externals, Base/Core internals, the DiffEqBase _process_verbose_param internal, and OrdinaryDiffEqCore's own re-exported names for dependent sublibraries). Co-Authored-By: Chris Rackauckas <accounts@chrisrackauckas.com>

…phase B) Now that the on-branch OrdinaryDiffEqCore declares its solver-author extension API public, four names that were previously ignored in all_explicit_imports_are_public have become public and are dropped: CompiledFloats, DerivativeOrderNotPossibleError, _ode_interpolant!, isdp8. The genuine residual is only: - @tight_loop_macros (DiffEqBase-internal codegen macro, still non-public upstream; also the no_stale false positive from @muladd-hidden usage). - trivial_limiter! (OrdinaryDiffEqCore-internal no-op limiter default, deliberately kept non-public). Verified on Julia 1.12 against the in-repo lib/* [sources]: ExplicitImports 6/6 pass, full Quality Assurance 17/17. Co-Authored-By: Chris Rackauckas <accounts@chrisrackauckas.com>

… decls Drop BS3Cache/BS3ConstantCache/RK4Cache/RK4ConstantCache now that they are declared public in OrdinaryDiffEqLowOrderRK. Only trivial_limiter! (OrdinaryDiffEqCore, deliberately owner-internal) remains ignored. Co-Authored-By: Chris Rackauckas <accounts@chrisrackauckas.com>

@threaded

Drop the now-public OrdinaryDiffEqCore names (CompiledFloats, _fixup_ad, differentiation_rk_docstring, get_current_alg_order, reset_alg_dependent_opts!, resolve_basic) that are declared public on this branch. Keep only the genuine residual: OrdinaryDiffEqCore's private @threaded macro and _resolved_QT helper, plus upstream SciMLBase/FastPower/Base.Threads internals with no public replacement. Verified run_qa EI green (17/17) on Julia 1.12. Co-Authored-By: Chris Rackauckas <accounts@chrisrackauckas.com>

Now that OrdinaryDiffEqCore / OrdinaryDiffEqDifferentiation / DiffEqBase declare their solver-author extension API public on this branch, drop the now-redundant ignore entries. Only three genuine residuals remain: _fixup_ad / fsal_typeof (OrdinaryDiffEqCore owner-internal helpers) and _unwrap_val (SciMLBase, pending SciML#1412). The whole all_qualified_accesses_are_public ignore list is now empty and removed. Wire DiffEqBase and OrdinaryDiffEqDifferentiation as in-repo [sources] so the QA env resolves the on-branch public declarations. Co-Authored-By: Chris Rackauckas <accounts@chrisrackauckas.com>

Empty-ignore EI probe on the branch (Core/RKN/DiffEqBase dev'd from lib/* so the PHASE A public decls apply) flags only `@def` (SciMLBase) and `@tight_loop_macros` (DiffEqBase), both owner-internal codegen/perf macros. Drop the now-public `CompiledFloats` and `_ode_interpolant!` (OrdinaryDiffEqCore made them public on this branch). All 6 EI checks pass. Co-Authored-By: Chris Rackauckas <accounts@chrisrackauckas.com>

@threaded

Drop dead ignore entries (_fixup_ad, differentiation_rk_docstring — never imported by PDIRK) now that the base solver-author API is declared public. Residual: @threaded (OrdinaryDiffEqCore private codegen macro) and _unwrap_val (non-public on the registered SciMLBase release). Co-Authored-By: Chris Rackauckas <accounts@chrisrackauckas.com>

CompiledFloats is now public in OrdinaryDiffEqCore on this branch (PHASE A), so the sole all_explicit_imports_are_public ignore is redundant. All six ExplicitImports checks pass with empty ignore lists on Julia 1.12. Co-Authored-By: Chris Rackauckas <accounts@chrisrackauckas.com>

…ore list PHASE B re-clean follow-up: with the OrdinaryDiffEqCore solver-author API declared `public` on this branch, fac_default_gamma / _fixup_ad / isnewton are no longer flagged by ExplicitImports, so their ignore entries were redundant. Drop them; keep only the genuine residual (SciMLBase internals _unwrap_val / _reshape / _vec, not public on registered releases). Verified on Julia 1.12 (in-repo lib/* developed via native [sources] so the on-branch public decls are active): empty-ignore probe flags only the 3 SciMLBase names; with the tight list, ExplicitImports 6/6 pass, 0 flags. Co-Authored-By: Chris Rackauckas <accounts@chrisrackauckas.com>

@fold

PHASE B re-clean: probe with emptied EI ignore lists on Julia 1.12 against the on-branch PHASE-A public decls (OrdinaryDiffEqCore/DiffEqBase now declare their solver-author API public) shows only 7 genuinely non-public residual names. Drop the stale entries the prior pass over-kept (CompiledFloats, DerivativeOrderNotPossibleError, _ode_interpolant! — all now public), plus @def/@truncate_stacktrace from all_qualified where they never flagged. Residual kept (ground-truth flagged, grouped by owner): all_qualified_accesses_are_public: lorenz, lorenz_oop (OrdinaryDiffEqCore precompile-workload helpers, deliberately non-public) all_explicit_imports_are_public: @fold, @OnDemandTableauExtract, trivial_limiter! (OrdinaryDiffEqCore owner-internal codegen/limiter), @def (SciMLBase), @truncate_stacktrace (TruncatedStacktraces) Verified GROUP=QA EI on Julia 1.12: Quality Assurance 6/6 pass, 0 fail/error/broken. Co-Authored-By: Chris Rackauckas <accounts@chrisrackauckas.com>

Drop fac_default_gamma and has_dtnew_modification from the all_explicit_imports_are_public ignore list: both are now declared public in OrdinaryDiffEqCore on this branch. The remaining residual is the two SciMLBase-owned helpers (_vec, value) that are not yet public on the registered SciMLBase (pending release). Co-Authored-By: Chris Rackauckas <accounts@chrisrackauckas.com>

StochasticDiffEqCore declares @cache public on this branch (PHASE A), so it no longer needs an explicit_imports ignore. Only the genuine residual @.. (FastBroadcast macro reexported non-public through DiffEqBase) remains. Co-Authored-By: Chris Rackauckas <accounts@chrisrackauckas.com>

…ies QA ignore DerivativeOrderNotPossibleError, _ode_interpolant!, and get_current_alg_order are declared `public` in OrdinaryDiffEqCore on this branch, so they no longer need to be ignored by the ExplicitImports public-API checks. Trim them from the all_explicit_imports_are_public ignore list, leaving only the genuine residual (trivial_limiter! plus the external TruncatedStacktraces/FunctionWrappers names). Co-Authored-By: Chris Rackauckas <accounts@chrisrackauckas.com>

The solver-author API of OrdinaryDiffEqCore is now declared public on this branch, so drop the six now-public names (CompiledFloats, _fixup_ad, current_extrapolant!, isesdirk, isnewton, ssp_coefficient) from the all_explicit_imports_are_public ignore list. The remaining residual is the genuine set still flagged by run_qa with emptied ignore lists on Julia 1.12: lorenz/lorenz_oop/trivial_limiter! (OrdinaryDiffEqCore internals), _reshape/ _unwrap_val/_vec (SciMLBase private), @truncate_stacktrace (TruncatedStacktraces) and constructorof (ConstructionBase via SciMLBase re-export). Co-Authored-By: Chris Rackauckas <accounts@chrisrackauckas.com>

…ean) PHASE A declared the solver-author API public on this branch: OrdinaryDiffEqCore now `public`-declares current_extrapolant! (and perform_step!/issplit/current_extrapolant), and StochasticDiffEqCore `public`-declares @cache. With the on-branch lib/* [sources] siblings, all_explicit_imports_are_public passes with no ignores, so the entire ei_kwargs ignore list is redundant and removed. Verified on Julia 1.12 (SciMLTesting 1.7, in-repo [sources]): ExplicitImports 6/6 pass with empty ei_kwargs. (The unrelated Aqua undefined-exports failure for checkSRAOrder/checkSRIOrder is pre-existing, owned by StochasticDiffEqCore's export line and reexported here; out of scope for this EI re-clean.) Co-Authored-By: Chris Rackauckas <accounts@chrisrackauckas.com>

…ls (phase B) Re-clean the ExplicitImports ignore lists now that OrdinaryDiffEqCore / OrdinaryDiffEqDifferentiation / DiffEqBase / SciMLBase declare their solver-author extension API public on this branch. The bloated per-name ignore list (50 explicit + 9 qualified) collapses to the genuine residual: cross-package internals whose owner keeps them non-public, plus a couple of owner-internal Core helpers. Source: the four derivative/jacobian wrappers (TimeDerivativeWrapper, TimeGradientWrapper, UDerivativeWrapper, UJacobianWrapper) moved to SciMLBase (where they are now public) and are no longer re-exported by OrdinaryDiffEqDifferentiation, so import them from SciMLBase; without this OrdinaryDiffEqRosenbrock fails to precompile (UndefVarError TimeGradientWrapper). Import the now-public resize_J_W! from its owner OrdinaryDiffEqCore instead of via OrdinaryDiffEqDifferentiation so it drops from the ignore list. Also drop a duplicate UJacobianWrapper from the Differentiation import. Verified on Julia 1.12.6 against released SciMLTesting 1.7: full QA 17/17 (Aqua + JET + 6 ExplicitImports checks), 0 fail/error/broken, no Unexpected Pass. Co-Authored-By: Chris Rackauckas <accounts@chrisrackauckas.com>

… lists Re-probe on the branch with in-repo lib/* dev-pathed (PHASE A public decls active) flags a smaller residual than the prior pass kept. Drop the OrdinaryDiffEqCore names now declared public (apply_step!, error_constant, has_special_newton_error, _initialize_dae!, isnewton) and the qualified-access -only SciMLBase/ForwardDiff names that never flag under all_explicit_imports_are_public. Residual is now the genuine externals: SciMLBase/SciMLOperators/ForwardDiff/ StaticArraysCore internals plus @SciMLMessage (owner SciMLLogging) and the W-operator types. Co-Authored-By: Chris Rackauckas <accounts@chrisrackauckas.com>

Drop the 16 OrdinaryDiffEqCore names now declared public on-branch (round-1 solver-author extension API plus round-2 cross-sublib cache/tableau/error types). Keep only the genuine residual that still flags against the on-branch lib/* develop on Julia 1.12: lorenz/lorenz_oop precompile fixtures, the OrdinaryDiffEqCore owner-internal helpers _resolved_QT/trivial_limiter!, SciMLBase _unwrap_val, and the TruncatedStacktraces @truncate_stacktrace macro. Co-Authored-By: Chris Rackauckas <accounts@chrisrackauckas.com>

… public The OrdinaryDiffEqCore / Differentiation / NonlinearSolve / DiffEqBase solver-author extension API is now declared `public` on this branch, so the enumerated ignore entries for those names are redundant. Drop them and keep only the genuine residual: - SciMLBase abstract problem/function/algorithm types pending SciMLBase#1412 - SciMLBase init/save/step plumbing and DiffEqBase Stats not yet public - OrdinaryDiffEqCore DDE-specific integrator/discontinuity/tstop/saveat hooks that were not part of the public extension surface declared on this branch - ForwardDiff.Dual (external internal) QUALIFIED_INTERNAL: 94 -> 40, EXPLICIT_INTERNAL: 14 -> 3. Verified green on Julia 1.12 (all 6 ExplicitImports checks pass). Co-Authored-By: Chris Rackauckas <accounts@chrisrackauckas.com>

@threaded

…I made public Trim all_explicit_imports_are_public ignores for OrdinaryDiffEqFIRK to the genuine non-public residual. The OrdinaryDiffEqCore / OrdinaryDiffEqDifferentiation / OrdinaryDiffEqNonlinearSolve / DiffEqBase solver-author names are now declared `public` on this branch, so the following redundant entries were dropped (verified as Unexpected Pass on Julia 1.12.6 against the on-branch libs): _fixup_ad, _ode_interpolant!, alg_can_repeat_jac, differentiation_rk_docstring, get_current_alg_order, get_current_qmax, has_stiff_interpolation, isfirk, set_discontinuity. Remaining residual (all still genuinely non-public in their owner): @threaded, trivial_limiter! (OrdinaryDiffEqCore); _reshape, _unwrap_val, _vec, value (SciMLBase, pending SciML#1412); fastpower (FastPower); AbstractSciMLOperator (SciMLOperators). OrdinaryDiffEqLowStorageRK was already tight (verified green, no change). run_qa EI green (17/17) for both on Julia 1.12.6. Co-Authored-By: Chris Rackauckas <accounts@chrisrackauckas.com>

Drop the entire all_explicit_imports_are_public ignore (AutoAlgSwitch, AutoSwitchCache, CompositeAlgorithm, alg_stability_size, beta1_default, beta2_default, default_autoswitch, is_mass_matrix_alg, isdefaultalg) -- all nine are now declared public in OrdinaryDiffEqCore on this branch, so the check passes clean with no ignores. Drop FunctionWrapperSpecialize/NoSpecialize from all_qualified_accesses_are_public -- both are public in the resolved SciMLBase (>= 3.30.1) and no longer flagged. Keep only lorenz/lorenz_oop, which are OrdinaryDiffEqCore precompile-workload test fixtures. The DefaultSolverChoice enum unanalyzable handling and the mis-flagged stale solver-name ignores remain (genuine ExplicitImports limitation). Co-Authored-By: Chris Rackauckas <accounts@chrisrackauckas.com>

ChrisRackauckas-Claude · 2026-07-05T05:25:59Z

Did the sublibrary QA jobs run? No — the whole sublibrary `test` matrix failed to instantiate.

Investigated the "did these QA jobs even run?" question. Findings:

The Sublibrary CI run for this PR (run 28648595333) contains exactly one job — sublibrary-ci / detect (success) — yet the run is marked failure. Zero test cells spawned, so no sublibrary QA job ran (only the root-package tests / QA (julia 1) ran, and it passed).
Root cause: GitHub's hard 256-jobs-per-matrix cap. detect correctly computed a valid projects-matrix and set has_changes=true — but at this PR's base the matrix was 266 cells (incl. 56 QA cells, one per touched sublib). sublibrary-project-tests.yml's test job feeds that whole list into a single strategy.matrix on a uses: reusable-workflow call. 266 > 256 → GitHub instantiates no cells and fails the run with nothing scheduled (no per-cell annotation).
The wiring is otherwise correct: every converted sublib's test_groups.toml declares [QA], and compute_affected_sublibraries.jl emits QA cells for test-only test/qa/** changes. Proof: an 87-cell master push spawned fine with 20 QA cells, and the 4-cell ExplicitRK PR spawned its [QA] cell. It's purely the 266 > 256 scale that broke this PR.

Fix (upstream, where the bug lives): SciML/.github#107 shards the affected-sublibrary matrix into 200-cell batches across parallel test-N jobs so no single matrix exceeds 256. Validated locally by replaying the detect logic against the real 266-cell matrix (shard_1=200/shard_2=66, all 56 QA cells preserved, union == original). Once that merges and v1 is retagged, re-running this PR's Sublibrary CI will actually schedule (and run) all the sublib QA jobs.

Nothing to change in OrdinaryDiffEq.jl itself for this — the matrix mechanism is entirely in the reusable workflow.

🤖 Generated with Claude Code

ChrisRackauckas-Claude mentioned this pull request Jun 25, 2026

ExplicitImports: drive sublibrary QA checks to green (ei_broken markers) #3776

Open

ChrisRackauckas-Claude force-pushed the qa-run_qa-v16-ei branch from 95fe7f8 to 407db7a Compare June 27, 2026 05:17

ChrisRackauckas-Claude marked this pull request as ready for review June 29, 2026 09:51

ChrisRackauckas and others added 27 commits July 3, 2026 04:13

ChrisRackauckas added 25 commits July 3, 2026 04:18

ChrisRackauckas-Claude force-pushed the qa-run_qa-v16-ei branch from 10d44b2 to 299dccb Compare July 3, 2026 08:31

ChrisRackauckas-Claude mentioned this pull request Jul 5, 2026

Shard sublibrary-project-tests matrix under GitHub's 256-job cap SciML/.github#107

Merged

ChrisRackauckas merged commit 661f605 into SciML:master Jul 5, 2026
69 of 123 checks passed

ChrisRackauckas-Claude mentioned this pull request Jul 8, 2026

Initialize sparse Jacobian caches with stored values #3833

Merged

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Uh oh!

Uh oh!

QA: run_qa v1.6 form + ExplicitImports (root + sublibs)#3777

QA: run_qa v1.6 form + ExplicitImports (root + sublibs)#3777
ChrisRackauckas merged 108 commits into
SciML:masterfrom
ChrisRackauckas-Claude:qa-run_qa-v16-ei

ChrisRackauckas-Claude commented Jun 25, 2026

Uh oh!

ChrisRackauckas-Claude commented Jul 5, 2026

Uh oh!

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

3 participants

Uh oh!

Uh oh!

Conversation

ChrisRackauckas-Claude commented Jun 25, 2026

What changed

Verified locally (released SciMLTesting 1.6.0)

Pre-existing failures (NOT introduced here)

Uh oh!

ChrisRackauckas-Claude commented Jul 5, 2026

Did the sublibrary QA jobs run? No — the whole sublibrary test matrix failed to instantiate.

Uh oh!

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

3 participants

Did the sublibrary QA jobs run? No — the whole sublibrary `test` matrix failed to instantiate.