Package evaluation of OpenMDAOCore on Julia 1.13.0-DEV.1114 (7de5585024*) started at 2025-09-13T23:28:59.450


################################################################################
# Set-up
#

Installing PkgEval dependencies (TestEnv)...

Set-up completed after 9.73s


################################################################################
# Installation
#

Installing OpenMDAOCore...
   Resolving package versions...
    Updating `~/.julia/environments/v1.13/Project.toml`
  [24d19c10] + OpenMDAOCore v0.3.2
    Updating `~/.julia/environments/v1.13/Manifest.toml`
  [47edcb42] + ADTypes v1.18.0
  [79e6a3ab] + Adapt v4.3.0
  [4fba245c] + ArrayInterface v7.20.0
  [d360d2e6] + ChainRulesCore v1.26.0
  [f70d9fcc] + CommonWorldInvalidations v1.0.0
  [34da2185] + Compat v4.18.0
  [b0b7db55] + ComponentArrays v0.15.29
  [187b0558] + ConstructionBase v1.6.0
⌅ [864edb3b] + DataStructures v0.18.22
⌅ [a0c0ee7d] + DifferentiationInterface v0.6.54
  [ffbed154] + DocStringExtensions v0.9.5
  [d9f16b24] + Functors v0.5.2
  [615f187c] + IfElse v0.1.1
  [24d19c10] + OpenMDAOCore v0.3.2
  [bac558e1] + OrderedCollections v1.8.1
  [aea7be01] + PrecompileTools v1.3.3
  [21216c6a] + Preferences v1.5.0
  [ae029012] + Requires v1.3.1
  [0a514795] + SparseMatrixColorings v0.4.21
  [aedffcd0] + Static v1.2.0
  [0d7ed370] + StaticArrayInterface v1.8.0
  [1e83bf80] + StaticArraysCore v1.4.3
  [1986cc42] + Unitful v1.24.0
  [6fb2a4bd] + UnitfulAngles v0.7.2
  [56f22d72] + Artifacts v1.11.0
  [2a0f44e3] + Base64 v1.11.0
  [ade2ca70] + Dates v1.11.0
  [b77e0a4c] + InteractiveUtils v1.11.0
  [ac6e5ff7] + JuliaSyntaxHighlighting v1.12.0
  [8f399da3] + Libdl v1.11.0
  [37e2e46d] + LinearAlgebra v1.13.0
  [d6f4376e] + Markdown v1.11.0
  [de0858da] + Printf v1.11.0
  [9a3f8284] + Random v1.11.0
  [ea8e919c] + SHA v0.7.0
  [9e88b42a] + Serialization v1.11.0
  [2f01184e] + SparseArrays v1.13.0
  [f489334b] + StyledStrings v1.11.0
  [fa267f1f] + TOML v1.0.3
  [cf7118a7] + UUIDs v1.11.0
  [4ec0a83e] + Unicode v1.11.0
  [e66e0078] + CompilerSupportLibraries_jll v1.3.0+1
  [4536629a] + OpenBLAS_jll v0.3.29+0
  [bea87d4a] + SuiteSparse_jll v7.10.1+0
  [8e850b90] + libblastrampoline_jll v5.13.1+0
        Info Packages marked with ⌅ have new versions available but compatibility constraints restrict them from upgrading. To see why use `status --outdated -m`

Installation completed after 3.59s


################################################################################
# Precompilation
#

Precompiling PkgEval dependencies...

Precompiling package dependencies...
ERROR: LoadError: The following 6 direct dependencies failed to precompile:

EnzymeSpecialFunctionsExt 

Failed to precompile EnzymeSpecialFunctionsExt [bc91e8c5-4631-5c58-9d34-c5da8b408cf1] to "/home/pkgeval/.julia/compiled/v1.13/EnzymeSpecialFunctionsExt/jl_IdkdV3" (ProcessExited(1)).
ERROR: LoadError: InitError: UndefVarError: `libEnzyme` not defined in `Enzyme.API`
Suggestion: check for spelling errors or missing imports.
Stacktrace:
  [1] __init__()
    @ Enzyme.API ~/.julia/packages/Enzyme/ez9it/src/api.jl:1405
  [2] run_module_init(mod::Module, i::Int64)
    @ Base ./loading.jl:1417
  [3] register_restored_modules(sv::Core.SimpleVector, pkg::Base.PkgId, path::String)
    @ Base ./loading.jl:1405
  [4] _include_from_serialized(pkg::Base.PkgId, path::String, ocachepath::Nothing, depmods::Vector{Any}; register::Bool)
    @ Base ./loading.jl:1293
  [5] _include_from_serialized
    @ ./loading.jl:1247 [inlined]
  [6] _require_search_from_serialized(pkg::Base.PkgId, sourcepath::String, build_id::UInt128, stalecheck::Bool; reasons::Dict{String, Int64}, DEPOT_PATH::Vector{String})
    @ Base ./loading.jl:2105
  [7] _require_search_from_serialized
    @ ./loading.jl:1999 [inlined]
  [8] __require_prelocked(pkg::Base.PkgId, env::String)
    @ Base ./loading.jl:2649
  [9] _require_prelocked(uuidkey::Base.PkgId, env::String)
    @ Base ./loading.jl:2515
 [10] macro expansion
    @ ./loading.jl:2443 [inlined]
 [11] macro expansion
    @ ./lock.jl:376 [inlined]
 [12] __require(into::Module, mod::Symbol)
    @ Base ./loading.jl:2407
 [13] require
    @ ./loading.jl:2383 [inlined]
 [14] eval_import_path
    @ ./module.jl:36 [inlined]
 [15] eval_import_path_all(at::Module, path::Expr, keyword::String)
    @ Base ./module.jl:60
 [16] _eval_using(to::Module, path::Expr)
    @ Base ./module.jl:137
 [17] top-level scope
    @ ~/.julia/packages/Enzyme/ez9it/ext/EnzymeSpecialFunctionsExt.jl:4
 [18] include(mod::Module, _path::String)
    @ Base ./Base.jl:308
 [19] include_package_for_output(pkg::Base.PkgId, input::String, depot_path::Vector{String}, dl_load_path::Vector{String}, load_path::Vector{String}, concrete_deps::Vector{Pair{Base.PkgId, UInt128}}, source::Nothing)
    @ Base ./loading.jl:3072
 [20] top-level scope
    @ stdin:5
 [21] eval(m::Module, e::Any)
    @ Core ./boot.jl:489
 [22] include_string(mapexpr::typeof(identity), mod::Module, code::String, filename::String)
    @ Base ./loading.jl:2918
 [23] include_string
    @ ./loading.jl:2928 [inlined]
 [24] exec_options(opts::Base.JLOptions)
    @ Base ./client.jl:328
 [25] _start()
    @ Base ./client.jl:563
during initialization of module API
in expression starting at /home/pkgeval/.julia/packages/Enzyme/ez9it/ext/EnzymeSpecialFunctionsExt.jl:1
in expression starting at stdin:5
SparseDiffToolsEnzymeExt 

Failed to precompile SparseDiffToolsEnzymeExt [961652c5-a2c8-5e69-a050-b99c9826cf88] to "/home/pkgeval/.julia/compiled/v1.13/SparseDiffToolsEnzymeExt/jl_wrFvP3" (ProcessExited(1)).
WARNING: Imported binding Compiler.mapany was undeclared at import time during import to Interpreter.
ERROR: LoadError: InitError: UndefVarError: `libEnzyme` not defined in `Enzyme.API`
Suggestion: check for spelling errors or missing imports.
Stacktrace:
  [1] __init__()
    @ Enzyme.API ~/.julia/packages/Enzyme/ez9it/src/api.jl:1405
  [2] run_module_init(mod::Module, i::Int64)
    @ Base ./loading.jl:1417
  [3] register_restored_modules(sv::Core.SimpleVector, pkg::Base.PkgId, path::String)
    @ Base ./loading.jl:1405
  [4] _include_from_serialized(pkg::Base.PkgId, path::String, ocachepath::Nothing, depmods::Vector{Any}; register::Bool)
    @ Base ./loading.jl:1293
  [5] _include_from_serialized
    @ ./loading.jl:1247 [inlined]
  [6] _tryrequire_from_serialized(pkg::Base.PkgId, path::String, ocachepath::Nothing)
    @ Base ./loading.jl:1993
  [7] __require_prelocked(pkg::Base.PkgId, env::String)
    @ Base ./loading.jl:2717
  [8] _require_prelocked(uuidkey::Base.PkgId, env::String)
    @ Base ./loading.jl:2515
  [9] macro expansion
    @ ./loading.jl:2443 [inlined]
 [10] macro expansion
    @ ./lock.jl:376 [inlined]
 [11] __require(into::Module, mod::Symbol)
    @ Base ./loading.jl:2407
 [12] require
    @ ./loading.jl:2383 [inlined]
 [13] eval_import_path
    @ ./module.jl:36 [inlined]
 [14] eval_import_path_all(at::Module, path::Expr, keyword::String)
    @ Base ./module.jl:60
 [15] _eval_using(to::Module, path::Expr)
    @ Base ./module.jl:137
 [16] top-level scope
    @ ~/.julia/packages/SparseDiffTools/TukJJ/ext/SparseDiffToolsEnzymeExt.jl:8
 [17] include(mod::Module, _path::String)
    @ Base ./Base.jl:308
 [18] include_package_for_output(pkg::Base.PkgId, input::String, depot_path::Vector{String}, dl_load_path::Vector{String}, load_path::Vector{String}, concrete_deps::Vector{Pair{Base.PkgId, UInt128}}, source::Nothing)
    @ Base ./loading.jl:3072
 [19] top-level scope
    @ stdin:5
 [20] eval(m::Module, e::Any)
    @ Core ./boot.jl:489
 [21] include_string(mapexpr::typeof(identity), mod::Module, code::String, filename::String)
    @ Base ./loading.jl:2918
 [22] include_string
    @ ./loading.jl:2928 [inlined]
 [23] exec_options(opts::Base.JLOptions)
    @ Base ./client.jl:328
 [24] _start()
    @ Base ./client.jl:563
during initialization of module API
in expression starting at /home/pkgeval/.julia/packages/SparseDiffTools/TukJJ/ext/SparseDiffToolsEnzymeExt.jl:1
in expression starting at stdin:5

EnzymeLogExpFunctionsExt 

Failed to precompile EnzymeLogExpFunctionsExt [1a9f04a6-12b6-5435-a00e-55b0a0022015] to "/home/pkgeval/.julia/compiled/v1.13/EnzymeLogExpFunctionsExt/jl_pk6UPT" (ProcessExited(1)).
ERROR: LoadError: InitError: UndefVarError: `libEnzyme` not defined in `Enzyme.API`
Suggestion: check for spelling errors or missing imports.
Stacktrace:
  [1] __init__()
    @ Enzyme.API ~/.julia/packages/Enzyme/ez9it/src/api.jl:1405
  [2] run_module_init(mod::Module, i::Int64)
    @ Base ./loading.jl:1417
  [3] register_restored_modules(sv::Core.SimpleVector, pkg::Base.PkgId, path::String)
    @ Base ./loading.jl:1405
  [4] _include_from_serialized(pkg::Base.PkgId, path::String, ocachepath::Nothing, depmods::Vector{Any}; register::Bool)
    @ Base ./loading.jl:1293
  [5] _include_from_serialized
    @ ./loading.jl:1247 [inlined]
  [6] _require_search_from_serialized(pkg::Base.PkgId, sourcepath::String, build_id::UInt128, stalecheck::Bool; reasons::Dict{String, Int64}, DEPOT_PATH::Vector{String})
    @ Base ./loading.jl:2105
  [7] _require_search_from_serialized
    @ ./loading.jl:1999 [inlined]
  [8] __require_prelocked(pkg::Base.PkgId, env::String)
    @ Base ./loading.jl:2649
  [9] _require_prelocked(uuidkey::Base.PkgId, env::String)
    @ Base ./loading.jl:2515
 [10] macro expansion
    @ ./loading.jl:2443 [inlined]
 [11] macro expansion
    @ ./lock.jl:376 [inlined]
 [12] __require(into::Module, mod::Symbol)
    @ Base ./loading.jl:2407
 [13] require
    @ ./loading.jl:2383 [inlined]
 [14] eval_import_path
    @ ./module.jl:36 [inlined]
 [15] eval_import_path_all(at::Module, path::Expr, keyword::String)
    @ Base ./module.jl:60
 [16] _eval_using(to::Module, path::Expr)
    @ Base ./module.jl:137
 [17] top-level scope
    @ ~/.julia/packages/Enzyme/ez9it/ext/EnzymeLogExpFunctionsExt.jl:4
 [18] include(mod::Module, _path::String)
    @ Base ./Base.jl:308
 [19] include_package_for_output(pkg::Base.PkgId, input::String, depot_path::Vector{String}, dl_load_path::Vector{String}, load_path::Vector{String}, concrete_deps::Vector{Pair{Base.PkgId, UInt128}}, source::Nothing)
    @ Base ./loading.jl:3072
 [20] top-level scope
    @ stdin:5
 [21] eval(m::Module, e::Any)
    @ Core ./boot.jl:489
 [22] include_string(mapexpr::typeof(identity), mod::Module, code::String, filename::String)
    @ Base ./loading.jl:2918
 [23] include_string
    @ ./loading.jl:2928 [inlined]
 [24] exec_options(opts::Base.JLOptions)
    @ Base ./client.jl:328
 [25] _start()
    @ Base ./client.jl:563
during initialization of module API
in expression starting at /home/pkgeval/.julia/packages/Enzyme/ez9it/ext/EnzymeLogExpFunctionsExt.jl:1
in expression starting at stdin:5

EnzymeChainRulesCoreExt 

Failed to precompile EnzymeChainRulesCoreExt [dea36ce8-68cc-5ac3-8d54-6d6fec99b42c] to "/home/pkgeval/.julia/compiled/v1.13/EnzymeChainRulesCoreExt/jl_ucIpil" (ProcessExited(1)).
ERROR: LoadError: InitError: UndefVarError: `libEnzyme` not defined in `Enzyme.API`
Suggestion: check for spelling errors or missing imports.
Stacktrace:
  [1] __init__()
    @ Enzyme.API ~/.julia/packages/Enzyme/ez9it/src/api.jl:1405
  [2] run_module_init(mod::Module, i::Int64)
    @ Base ./loading.jl:1417
  [3] register_restored_modules(sv::Core.SimpleVector, pkg::Base.PkgId, path::String)
    @ Base ./loading.jl:1405
  [4] _include_from_serialized(pkg::Base.PkgId, path::String, ocachepath::Nothing, depmods::Vector{Any}; register::Bool)
    @ Base ./loading.jl:1293
  [5] _include_from_serialized
    @ ./loading.jl:1247 [inlined]
  [6] _require_search_from_serialized(pkg::Base.PkgId, sourcepath::String, build_id::UInt128, stalecheck::Bool; reasons::Dict{String, Int64}, DEPOT_PATH::Vector{String})
    @ Base ./loading.jl:2105
  [7] _require_search_from_serialized
    @ ./loading.jl:1999 [inlined]
  [8] __require_prelocked(pkg::Base.PkgId, env::String)
    @ Base ./loading.jl:2649
  [9] _require_prelocked(uuidkey::Base.PkgId, env::String)
    @ Base ./loading.jl:2515
 [10] macro expansion
    @ ./loading.jl:2443 [inlined]
 [11] macro expansion
    @ ./lock.jl:376 [inlined]
 [12] __require(into::Module, mod::Symbol)
    @ Base ./loading.jl:2407
 [13] require
    @ ./loading.jl:2383 [inlined]
 [14] eval_import_path
    @ ./module.jl:36 [inlined]
 [15] eval_import_path_all(at::Module, path::Expr, keyword::String)
    @ Base ./module.jl:60
 [16] _eval_using(to::Module, path::Expr)
    @ Base ./module.jl:137
 [17] top-level scope
    @ ~/.julia/packages/Enzyme/ez9it/ext/EnzymeChainRulesCoreExt.jl:5
 [18] include(mod::Module, _path::String)
    @ Base ./Base.jl:308
 [19] include_package_for_output(pkg::Base.PkgId, input::String, depot_path::Vector{String}, dl_load_path::Vector{String}, load_path::Vector{String}, concrete_deps::Vector{Pair{Base.PkgId, UInt128}}, source::Nothing)
    @ Base ./loading.jl:3072
 [20] top-level scope
    @ stdin:5
 [21] eval(m::Module, e::Any)
    @ Core ./boot.jl:489
 [22] include_string(mapexpr::typeof(identity), mod::Module, code::String, filename::String)
    @ Base ./loading.jl:2918
 [23] include_string
    @ ./loading.jl:2928 [inlined]
 [24] exec_options(opts::Base.JLOptions)
    @ Base ./client.jl:328
 [25] _start()
    @ Base ./client.jl:563
during initialization of module API
in expression starting at /home/pkgeval/.julia/packages/Enzyme/ez9it/ext/EnzymeChainRulesCoreExt.jl:1
in expression starting at stdin:5

EnzymeStaticArraysExt 

Failed to precompile EnzymeStaticArraysExt [8724f06c-f4c4-5d10-8ca5-5036e220244b] to "/home/pkgeval/.julia/compiled/v1.13/EnzymeStaticArraysExt/jl_IW9sCx" (ProcessExited(1)).
ERROR: LoadError: InitError: UndefVarError: `libEnzyme` not defined in `Enzyme.API`
Suggestion: check for spelling errors or missing imports.
Stacktrace:
  [1] __init__()
    @ Enzyme.API ~/.julia/packages/Enzyme/ez9it/src/api.jl:1405
  [2] run_module_init(mod::Module, i::Int64)
    @ Base ./loading.jl:1417
  [3] register_restored_modules(sv::Core.SimpleVector, pkg::Base.PkgId, path::String)
    @ Base ./loading.jl:1405
  [4] _include_from_serialized(pkg::Base.PkgId, path::String, ocachepath::Nothing, depmods::Vector{Any}; register::Bool)
    @ Base ./loading.jl:1293
  [5] _include_from_serialized
    @ ./loading.jl:1247 [inlined]
  [6] _require_search_from_serialized(pkg::Base.PkgId, sourcepath::String, build_id::UInt128, stalecheck::Bool; reasons::Dict{String, Int64}, DEPOT_PATH::Vector{String})
    @ Base ./loading.jl:2105
  [7] _require_search_from_serialized
    @ ./loading.jl:1999 [inlined]
  [8] __require_prelocked(pkg::Base.PkgId, env::String)
    @ Base ./loading.jl:2649
  [9] _require_prelocked(uuidkey::Base.PkgId, env::String)
    @ Base ./loading.jl:2515
 [10] macro expansion
    @ ./loading.jl:2443 [inlined]
 [11] macro expansion
    @ ./lock.jl:376 [inlined]
 [12] __require(into::Module, mod::Symbol)
    @ Base ./loading.jl:2407
 [13] require
    @ ./loading.jl:2383 [inlined]
 [14] eval_import_path
    @ ./module.jl:36 [inlined]
 [15] eval_import_path_all(at::Module, path::Expr, keyword::String)
    @ Base ./module.jl:60
 [16] _eval_using(to::Module, path::Expr)
    @ Base ./module.jl:137
 [17] top-level scope
    @ ~/.julia/packages/Enzyme/ez9it/ext/EnzymeStaticArraysExt.jl:4
 [18] include(mod::Module, _path::String)
    @ Base ./Base.jl:308
 [19] include_package_for_output(pkg::Base.PkgId, input::String, depot_path::Vector{String}, dl_load_path::Vector{String}, load_path::Vector{String}, concrete_deps::Vector{Pair{Base.PkgId, UInt128}}, source::Nothing)
    @ Base ./loading.jl:3072
 [20] top-level scope
    @ stdin:5
 [21] eval(m::Module, e::Any)
    @ Core ./boot.jl:489
 [22] include_string(mapexpr::typeof(identity), mod::Module, code::String, filename::String)
    @ Base ./loading.jl:2918
 [23] include_string
    @ ./loading.jl:2928 [inlined]
 [24] exec_options(opts::Base.JLOptions)
    @ Base ./client.jl:328
 [25] _start()
    @ Base ./client.jl:563
during initialization of module API
in expression starting at /home/pkgeval/.julia/packages/Enzyme/ez9it/ext/EnzymeStaticArraysExt.jl:1
in expression starting at stdin:5

EnzymeGPUArraysCoreExt 

Failed to precompile EnzymeGPUArraysCoreExt [6f04138c-15cb-59c5-94f1-55440044fc8e] to "/home/pkgeval/.julia/compiled/v1.13/EnzymeGPUArraysCoreExt/jl_2zoqoV" (ProcessExited(1)).
ERROR: LoadError: InitError: UndefVarError: `libEnzyme` not defined in `Enzyme.API`
Suggestion: check for spelling errors or missing imports.
Stacktrace:
  [1] __init__()
    @ Enzyme.API ~/.julia/packages/Enzyme/ez9it/src/api.jl:1405
  [2] run_module_init(mod::Module, i::Int64)
    @ Base ./loading.jl:1417
  [3] register_restored_modules(sv::Core.SimpleVector, pkg::Base.PkgId, path::String)
    @ Base ./loading.jl:1405
  [4] _include_from_serialized(pkg::Base.PkgId, path::String, ocachepath::Nothing, depmods::Vector{Any}; register::Bool)
    @ Base ./loading.jl:1293
  [5] _include_from_serialized
    @ ./loading.jl:1247 [inlined]
  [6] _require_search_from_serialized(pkg::Base.PkgId, sourcepath::String, build_id::UInt128, stalecheck::Bool; reasons::Dict{String, Int64}, DEPOT_PATH::Vector{String})
    @ Base ./loading.jl:2105
  [7] _require_search_from_serialized
    @ ./loading.jl:1999 [inlined]
  [8] __require_prelocked(pkg::Base.PkgId, env::String)
    @ Base ./loading.jl:2649
  [9] _require_prelocked(uuidkey::Base.PkgId, env::String)
    @ Base ./loading.jl:2515
 [10] macro expansion
    @ ./loading.jl:2443 [inlined]
 [11] macro expansion
    @ ./lock.jl:376 [inlined]
 [12] __require(into::Module, mod::Symbol)
    @ Base ./loading.jl:2407
 [13] require
    @ ./loading.jl:2383 [inlined]
 [14] eval_import_path
    @ ./module.jl:36 [inlined]
 [15] eval_import_path_all(at::Module, path::Expr, keyword::String)
    @ Base ./module.jl:60
 [16] _eval_using(to::Module, path::Expr)
    @ Base ./module.jl:137
 [17] top-level scope
    @ ~/.julia/packages/Enzyme/ez9it/ext/EnzymeGPUArraysCoreExt.jl:4
 [18] include(mod::Module, _path::String)
    @ Base ./Base.jl:308
 [19] include_package_for_output(pkg::Base.PkgId, input::String, depot_path::Vector{String}, dl_load_path::Vector{String}, load_path::Vector{String}, concrete_deps::Vector{Pair{Base.PkgId, UInt128}}, source::Nothing)
    @ Base ./loading.jl:3072
 [20] top-level scope
    @ stdin:5
 [21] eval(m::Module, e::Any)
    @ Core ./boot.jl:489
 [22] include_string(mapexpr::typeof(identity), mod::Module, code::String, filename::String)
    @ Base ./loading.jl:2918
 [23] include_string
    @ ./loading.jl:2928 [inlined]
 [24] exec_options(opts::Base.JLOptions)
    @ Base ./client.jl:328
 [25] _start()
    @ Base ./client.jl:563
during initialization of module API
in expression starting at /home/pkgeval/.julia/packages/Enzyme/ez9it/ext/EnzymeGPUArraysCoreExt.jl:1
in expression starting at stdin:5
in expression starting at /PkgEval.jl/scripts/precompile.jl:37

Precompilation failed after 260.72s



################################################################################
# Testing
#

     Testing OpenMDAOCore
      Status `/tmp/jl_DN0lkf/Project.toml`
  [47edcb42] ADTypes v1.18.0
  [b0b7db55] ComponentArrays v0.15.29
  [e30172f5] Documenter v1.14.1
  [7da242da] Enzyme v0.13.74
  [f151be2c] EnzymeCore v0.8.13
  [f6369f11] ForwardDiff v1.2.1
  [24d19c10] OpenMDAOCore v0.3.2
  [37e2e3b7] ReverseDiff v1.16.1
  [1bc83da4] SafeTestsets v0.1.0
  [47a9eef4] SparseDiffTools v2.26.0
  [0a514795] SparseMatrixColorings v0.4.21
  [1986cc42] Unitful v1.24.0
  [6fb2a4bd] UnitfulAngles v0.7.2
  [e88e6eb3] Zygote v0.7.10
  [2f01184e] SparseArrays v1.13.0
  [8dfed614] Test v1.11.0
      Status `/tmp/jl_DN0lkf/Manifest.toml`
  [47edcb42] ADTypes v1.18.0
  [a4c015fc] ANSIColoredPrinters v0.0.1
  [621f4979] AbstractFFTs v1.5.0
  [1520ce14] AbstractTrees v0.4.5
  [7d9f7c33] Accessors v0.1.42
  [79e6a3ab] Adapt v4.3.0
  [ec485272] ArnoldiMethod v0.4.0
  [4fba245c] ArrayInterface v7.20.0
  [fa961155] CEnum v0.5.0
  [082447d4] ChainRules v1.72.5
  [d360d2e6] ChainRulesCore v1.26.0
  [944b1d66] CodecZlib v0.7.8
  [bbf7d656] CommonSubexpressions v0.3.1
  [f70d9fcc] CommonWorldInvalidations v1.0.0
  [34da2185] Compat v4.18.0
  [b0b7db55] ComponentArrays v0.15.29
  [a33af91c] CompositionsBase v0.1.2
  [187b0558] ConstructionBase v1.6.0
  [9a962f9c] DataAPI v1.16.0
⌅ [864edb3b] DataStructures v0.18.22
  [e2d170a0] DataValueInterfaces v1.0.0
  [163ba53b] DiffResults v1.1.0
  [b552c78f] DiffRules v1.15.1
⌅ [a0c0ee7d] DifferentiationInterface v0.6.54
  [ffbed154] DocStringExtensions v0.9.5
  [e30172f5] Documenter v1.14.1
  [7da242da] Enzyme v0.13.74
  [f151be2c] EnzymeCore v0.8.13
  [e2ba6199] ExprTools v0.1.10
  [1a297f60] FillArrays v1.14.0
  [6a86dc24] FiniteDiff v2.28.1
  [f6369f11] ForwardDiff v1.2.1
  [069b7b12] FunctionWrappers v1.1.3
  [d9f16b24] Functors v0.5.2
  [46192b85] GPUArraysCore v0.2.0
  [61eb1bfa] GPUCompiler v1.6.1
  [d7ba0133] Git v1.5.0
  [86223c79] Graphs v1.13.1
  [b5f81e59] IOCapture v0.2.5
  [7869d1d1] IRTools v0.4.15
  [615f187c] IfElse v0.1.1
  [d25df0c9] Inflate v0.1.5
  [3587e190] InverseFunctions v0.1.17
  [92d709cd] IrrationalConstants v0.2.4
  [82899510] IteratorInterfaceExtensions v1.0.0
  [692b3bcd] JLLWrappers v1.7.1
  [682c06a0] JSON v0.21.4
  [929cbde3] LLVM v9.4.2
  [0e77f7df] LazilyInitializedFields v1.3.0
  [2ab3a3ac] LogExpFunctions v0.3.29
  [1914dd2f] MacroTools v0.5.16
  [d0879d2d] MarkdownAST v0.1.2
  [77ba4419] NaNMath v1.1.3
  [d8793406] ObjectFile v0.5.0
  [24d19c10] OpenMDAOCore v0.3.2
  [bac558e1] OrderedCollections v1.8.1
  [65ce6f38] PackageExtensionCompat v1.0.2
  [69de0a69] Parsers v2.8.3
  [aea7be01] PrecompileTools v1.3.3
  [21216c6a] Preferences v1.5.0
  [c1ae055f] RealDot v0.1.0
  [189a3867] Reexport v1.2.2
  [2792f1a3] RegistryInstances v0.1.0
  [ae029012] Requires v1.3.1
  [37e2e3b7] ReverseDiff v1.16.1
  [1bc83da4] SafeTestsets v0.1.0
⌅ [c0aeaf25] SciMLOperators v0.4.0
  [6c6a2e73] Scratch v1.3.0
  [efcf1570] Setfield v1.1.2
  [699a6c99] SimpleTraits v0.9.5
  [47a9eef4] SparseDiffTools v2.26.0
  [dc90abb0] SparseInverseSubset v0.1.2
  [0a514795] SparseMatrixColorings v0.4.21
  [276daf66] SpecialFunctions v2.5.1
  [aedffcd0] Static v1.2.0
  [0d7ed370] StaticArrayInterface v1.8.0
  [90137ffa] StaticArrays v1.9.15
  [1e83bf80] StaticArraysCore v1.4.3
  [10745b16] Statistics v1.11.1
  [09ab397b] StructArrays v0.7.1
  [53d494c1] StructIO v0.3.1
  [3783bdb8] TableTraits v1.0.1
  [bd369af6] Tables v1.12.1
  [e689c965] Tracy v0.1.6
  [3bb67fe8] TranscodingStreams v0.11.3
  [3a884ed6] UnPack v1.0.2
  [1986cc42] Unitful v1.24.0
  [6fb2a4bd] UnitfulAngles v0.7.2
  [19fa3120] VertexSafeGraphs v0.2.0
  [e88e6eb3] Zygote v0.7.10
  [700de1a5] ZygoteRules v0.2.7
  [7cc45869] Enzyme_jll v0.0.196+0
  [2e619515] Expat_jll v2.7.1+0
  [020c3dae] Git_LFS_jll v3.7.0+0
  [f8c6e375] Git_jll v2.51.1+0
  [dad2f222] LLVMExtra_jll v0.0.37+2
  [ad6e5548] LibTracyClient_jll v0.9.1+6
  [94ce4f54] Libiconv_jll v1.18.0+0
  [9bd350c2] OpenSSH_jll v10.0.1+0
  [efe28fd5] OpenSpecFun_jll v0.5.6+0
  [0dad84c5] ArgTools v1.1.2
  [56f22d72] Artifacts v1.11.0
  [2a0f44e3] Base64 v1.11.0
  [ade2ca70] Dates v1.11.0
  [8ba89e20] Distributed v1.11.0
  [f43a241f] Downloads v1.7.0
  [7b1f6079] FileWatching v1.11.0
  [9fa8497b] Future v1.11.0
  [b77e0a4c] InteractiveUtils v1.11.0
  [ac6e5ff7] JuliaSyntaxHighlighting v1.12.0
  [4af54fe1] LazyArtifacts v1.11.0
  [b27032c2] LibCURL v0.6.4
  [76f85450] LibGit2 v1.11.0
  [8f399da3] Libdl v1.11.0
  [37e2e46d] LinearAlgebra v1.13.0
  [56ddb016] Logging v1.11.0
  [d6f4376e] Markdown v1.11.0
  [a63ad114] Mmap v1.11.0
  [ca575930] NetworkOptions v1.3.0
  [44cfe95a] Pkg v1.13.0
  [de0858da] Printf v1.11.0
  [3fa0cd96] REPL v1.11.0
  [9a3f8284] Random v1.11.0
  [ea8e919c] SHA v0.7.0
  [9e88b42a] Serialization v1.11.0
  [1a1011a3] SharedArrays v1.11.0
  [6462fe0b] Sockets v1.11.0
  [2f01184e] SparseArrays v1.13.0
  [f489334b] StyledStrings v1.11.0
  [4607b0f0] SuiteSparse
  [fa267f1f] TOML v1.0.3
  [a4e569a6] Tar v1.10.0
  [8dfed614] Test v1.11.0
  [cf7118a7] UUIDs v1.11.0
  [4ec0a83e] Unicode v1.11.0
  [e66e0078] CompilerSupportLibraries_jll v1.3.0+1
  [deac9b47] LibCURL_jll v8.16.0+0
  [e37daf67] LibGit2_jll v1.9.1+0
  [29816b5a] LibSSH2_jll v1.11.3+1
  [14a3606d] MozillaCACerts_jll v2025.9.9
  [4536629a] OpenBLAS_jll v0.3.29+0
  [05823500] OpenLibm_jll v0.8.7+0
  [458c3c95] OpenSSL_jll v3.5.2+0
  [efcefdf7] PCRE2_jll v10.46.0+0
  [bea87d4a] SuiteSparse_jll v7.10.1+0
  [83775a58] Zlib_jll v1.3.1+2
  [3161d3a3] Zstd_jll v1.5.7+1
  [8e850b90] libblastrampoline_jll v5.13.1+0
  [8e850ede] nghttp2_jll v1.67.0+0
  [3f19e933] p7zip_jll v17.6.0+0
        Info Packages marked with ⌅ have new versions available but compatibility constraints restrict them from upgrading.
     Testing Running tests...
┌ Warning: Unable to determine HTML(edit_link = ...) from remote HEAD branch, defaulting to "master".
│ Calling `git remote` failed with an exception. Set JULIA_DEBUG=Documenter to see the error.
│ Unless this is due to a configuration error, the relevant variable should be set explicitly.
└ @ Documenter ~/.julia/packages/Documenter/eoWm2/src/utilities/utilities.jl:665
[ Info: SetupBuildDirectory: setting up build directory.
[ Info: Doctest: running doctests.
[ Info: Skipped ExpandTemplates step (doctest only).
[ Info: Skipped CrossReferences step (doctest only).
[ Info: Skipped CheckDocument step (doctest only).
[ Info: Skipped Populate step (doctest only).
[ Info: Skipped RenderDocument step (doctest only).
Test Summary: | Pass  Total     Time
doctests      |    1      1  1m33.9s
Test Summary: | Pass  Total  Time
VarData       |   84     84  2.1s
Test Summary: | Pass  Total  Time
PartialsData  |   59     59  3.3s
Test Summary:                     | Pass  Total  Time
Finding ExplicitComponent methods |   12     12  1.5s
Test Summary:                     | Pass  Total  Time
Finding ImplicitComponent methods |   56     56  1.4s
Test Summary: | Pass  Total  Time
get_rows_cols |   14     14  0.5s
Test Summary:                    | Pass  Total   Time
get_rows_cols_dict_from_sparsity |   68     68  21.8s
Test Summary: | Pass  Total   Time
unitfulify    |    6      6  14.4s
Test Summary: | Pass  Total  Time
Aviary utils  |  384    384  8.5s
Precompiling packages...
   6277.6 ms  ✓ Unitful → ForwardDiffExt
  1 dependency successfully precompiled in 7 seconds. 21 already precompiled.
Precompiling packages...
   1865.5 ms  ✓ DifferentiationInterface → DifferentiationInterfaceForwardDiffExt
  1 dependency successfully precompiled in 2 seconds. 21 already precompiled.
Precompiling packages...
   5070.6 ms  ✓ DifferentiationInterface → DifferentiationInterfaceStaticArraysExt
  1 dependency successfully precompiled in 5 seconds. 10 already precompiled.
Precompiling packages...
   7206.1 ms  ✓ DifferentiationInterface → DifferentiationInterfaceReverseDiffExt
  1 dependency successfully precompiled in 7 seconds. 39 already precompiled.

manual sparsity: Error During Test at /home/pkgeval/.julia/packages/SafeTestsets/raUNr/src/SafeTestsets.jl:30
  Got exception outside of a @test
  LoadError: InitError: UndefVarError: `libEnzyme` not defined in `Enzyme.API`
  Suggestion: check for spelling errors or missing imports.
  Stacktrace:
    [1] __init__()
      @ Enzyme.API ~/.julia/packages/Enzyme/ez9it/src/api.jl:1405
    [2] run_module_init(mod::Module, i::Int64)
      @ Base ./loading.jl:1417
    [3] register_restored_modules(sv::Core.SimpleVector, pkg::Base.PkgId, path::String)
      @ Base ./loading.jl:1405
    [4] _include_from_serialized(pkg::Base.PkgId, path::String, ocachepath::Nothing, depmods::Vector{Any}; register::Bool)
      @ Base ./loading.jl:1293
    [5] _include_from_serialized
      @ ./loading.jl:1247 [inlined]
    [6] _require_search_from_serialized(pkg::Base.PkgId, sourcepath::String, build_id::UInt128, stalecheck::Bool; reasons::Dict{String, Int64}, DEPOT_PATH::Vector{String})
      @ Base ./loading.jl:2105
    [7] _require_search_from_serialized
      @ ./loading.jl:1999 [inlined]
    [8] __require_prelocked(pkg::Base.PkgId, env::String)
      @ Base ./loading.jl:2649
    [9] _require_prelocked(uuidkey::Base.PkgId, env::String)
      @ Base ./loading.jl:2515
   [10] macro expansion
      @ ./loading.jl:2443 [inlined]
   [11] macro expansion
      @ ./lock.jl:376 [inlined]
   [12] __require(into::Module, mod::Symbol)
      @ Base ./loading.jl:2407
   [13] require
      @ ./loading.jl:2383 [inlined]
   [14] eval_import_path
      @ ./module.jl:36 [inlined]
   [15] eval_import_path_all(at::Module, path::Expr, keyword::String)
      @ Base ./module.jl:60
   [16] _eval_import(::Bool, ::Module, ::Expr, ::Expr, ::Vararg{Expr})
      @ Base ./module.jl:101
   [17] top-level scope
      @ ~/.julia/packages/OpenMDAOCore/v5KNT/test/autosparse_manual.jl:9
   [18] include(mapexpr::Function, mod::Module, _path::String)
      @ Base ./Base.jl:309
   [19] top-level scope
      @ ~/.julia/packages/SafeTestsets/raUNr/src/SafeTestsets.jl:678
   [20] macro expansion
      @ /opt/julia/share/julia/stdlib/v1.13/Test/src/Test.jl:1952 [inlined]
   [21] macro expansion
      @ ~/.julia/packages/OpenMDAOCore/v5KNT/test/runtests.jl:678 [inlined]
   [22] eval(m::Module, e::Any)
      @ Core ./boot.jl:489
   [23] top-level scope
      @ ~/.julia/packages/OpenMDAOCore/v5KNT/test/runtests.jl:677
   [24] macro expansion
      @ /opt/julia/share/julia/stdlib/v1.13/Test/src/Test.jl:1952 [inlined]
   [25] macro expansion
      @ ~/.julia/packages/OpenMDAOCore/v5KNT/test/runtests.jl:677 [inlined]
   [26] macro expansion
      @ ~/.julia/packages/SafeTestsets/raUNr/src/SafeTestsets.jl:28 [inlined]
   [27] include(mapexpr::Function, mod::Module, _path::String)
      @ Base ./Base.jl:309
   [28] top-level scope
      @ none:6
   [29] eval(m::Module, e::Any)
      @ Core ./boot.jl:489
   [30] exec_options(opts::Base.JLOptions)
      @ Base ./client.jl:296
   [31] _start()
      @ Base ./client.jl:563
  during initialization of module API
  in expression starting at /home/pkgeval/.julia/packages/OpenMDAOCore/v5KNT/test/autosparse_manual.jl:9
Precompiling packages...
   1645.3 ms  ✓ DifferentiationInterface → DifferentiationInterfaceGPUArraysCoreExt
  1 dependency successfully precompiled in 2 seconds. 6 already precompiled.
Precompiling packages...
   6852.0 ms  ✓ DifferentiationInterface → DifferentiationInterfaceZygoteExt
  1 dependency successfully precompiled in 8 seconds. 74 already precompiled.
Precompiling packages...
Info Given EnzymeLogExpFunctionsExt was explicitly requested, output will be shown live 
ERROR: LoadError: InitError: UndefVarError: `libEnzyme` not defined in `Enzyme.API`
Suggestion: check for spelling errors or missing imports.
Stacktrace:
  [1] __init__()
    @ Enzyme.API ~/.julia/packages/Enzyme/ez9it/src/api.jl:1405
  [2] run_module_init(mod::Module, i::Int64)
    @ Base ./loading.jl:1417
  [3] register_restored_modules(sv::Core.SimpleVector, pkg::Base.PkgId, path::String)
    @ Base ./loading.jl:1405
  [4] _include_from_serialized(pkg::Base.PkgId, path::String, ocachepath::Nothing, depmods::Vector{Any}; register::Bool)
    @ Base ./loading.jl:1293
  [5] _include_from_serialized
    @ ./loading.jl:1247 [inlined]
  [6] _require_search_from_serialized(pkg::Base.PkgId, sourcepath::String, build_id::UInt128, stalecheck::Bool; reasons::Dict{String, Int64}, DEPOT_PATH::Vector{String})
    @ Base ./loading.jl:2105
  [7] _require_search_from_serialized
    @ ./loading.jl:1999 [inlined]
  [8] __require_prelocked(pkg::Base.PkgId, env::String)
    @ Base ./loading.jl:2649
  [9] _require_prelocked(uuidkey::Base.PkgId, env::String)
    @ Base ./loading.jl:2515
 [10] macro expansion
    @ ./loading.jl:2443 [inlined]
 [11] macro expansion
    @ ./lock.jl:376 [inlined]
 [12] __require(into::Module, mod::Symbol)
    @ Base ./loading.jl:2407
 [13] require
    @ ./loading.jl:2383 [inlined]
 [14] eval_import_path
    @ ./module.jl:36 [inlined]
 [15] eval_import_path_all(at::Module, path::Expr, keyword::String)
    @ Base ./module.jl:60
 [16] _eval_using(to::Module, path::Expr)
    @ Base ./module.jl:137
 [17] top-level scope
    @ ~/.julia/packages/Enzyme/ez9it/ext/EnzymeLogExpFunctionsExt.jl:4
 [18] include(mod::Module, _path::String)
    @ Base ./Base.jl:308
 [19] include_package_for_output(pkg::Base.PkgId, input::String, depot_path::Vector{String}, dl_load_path::Vector{String}, load_path::Vector{String}, concrete_deps::Vector{Pair{Base.PkgId, UInt128}}, source::Nothing)
    @ Base ./loading.jl:3072
 [20] top-level scope
    @ stdin:5
 [21] eval(m::Module, e::Any)
    @ Core ./boot.jl:489
 [22] include_string(mapexpr::typeof(identity), mod::Module, code::String, filename::String)
    @ Base ./loading.jl:2918
 [23] include_string
    @ ./loading.jl:2928 [inlined]
 [24] exec_options(opts::Base.JLOptions)
    @ Base ./client.jl:328
 [25] _start()
    @ Base ./client.jl:563
during initialization of module API
in expression starting at /home/pkgeval/.julia/packages/Enzyme/ez9it/ext/EnzymeLogExpFunctionsExt.jl:1
in expression starting at stdin:5
              ✗ Enzyme → EnzymeLogExpFunctionsExt
  0 dependencies successfully precompiled in 15 seconds. 52 already precompiled.

┌ Error: Error during loading of extension EnzymeLogExpFunctionsExt of Enzyme, use `Base.retry_load_extensions()` to retry.
│   exception =
│    1-element ExceptionStack:
│    The following 1 direct dependency failed to precompile:
│    
│    EnzymeLogExpFunctionsExt 
│    
│    Failed to precompile EnzymeLogExpFunctionsExt [1a9f04a6-12b6-5435-a00e-55b0a0022015] to "/home/pkgeval/.julia/compiled/v1.13/EnzymeLogExpFunctionsExt/jl_BCPAjD" (ProcessExited(1)).
│    ERROR: LoadError: InitError: UndefVarError: `libEnzyme` not defined in `Enzyme.API`
│    Suggestion: check for spelling errors or missing imports.
│    Stacktrace:
│      [1] __init__()
│        @ Enzyme.API ~/.julia/packages/Enzyme/ez9it/src/api.jl:1405
│      [2] run_module_init(mod::Module, i::Int64)
│        @ Base ./loading.jl:1417
│      [3] register_restored_modules(sv::Core.SimpleVector, pkg::Base.PkgId, path::String)
│        @ Base ./loading.jl:1405
│      [4] _include_from_serialized(pkg::Base.PkgId, path::String, ocachepath::Nothing, depmods::Vector{Any}; register::Bool)
│        @ Base ./loading.jl:1293
│      [5] _include_from_serialized
│        @ ./loading.jl:1247 [inlined]
│      [6] _require_search_from_serialized(pkg::Base.PkgId, sourcepath::String, build_id::UInt128, stalecheck::Bool; reasons::Dict{String, Int64}, DEPOT_PATH::Vector{String})
│        @ Base ./loading.jl:2105
│      [7] _require_search_from_serialized
│        @ ./loading.jl:1999 [inlined]
│      [8] __require_prelocked(pkg::Base.PkgId, env::String)
│        @ Base ./loading.jl:2649
│      [9] _require_prelocked(uuidkey::Base.PkgId, env::String)
│        @ Base ./loading.jl:2515
│     [10] macro expansion
│        @ ./loading.jl:2443 [inlined]
│     [11] macro expansion
│        @ ./lock.jl:376 [inlined]
│     [12] __require(into::Module, mod::Symbol)
│        @ Base ./loading.jl:2407
│     [13] require
│        @ ./loading.jl:2383 [inlined]
│     [14] eval_import_path
│        @ ./module.jl:36 [inlined]
│     [15] eval_import_path_all(at::Module, path::Expr, keyword::String)
│        @ Base ./module.jl:60
│     [16] _eval_using(to::Module, path::Expr)
│        @ Base ./module.jl:137
│     [17] top-level scope
│        @ ~/.julia/packages/Enzyme/ez9it/ext/EnzymeLogExpFunctionsExt.jl:4
│     [18] include(mod::Module, _path::String)
│        @ Base ./Base.jl:308
│     [19] include_package_for_output(pkg::Base.PkgId, input::String, depot_path::Vector{String}, dl_load_path::Vector{String}, load_path::Vector{String}, concrete_deps::Vector{Pair{Base.PkgId, UInt128}}, source::Nothing)
│        @ Base ./loading.jl:3072
│     [20] top-level scope
│        @ stdin:5
│     [21] eval(m::Module, e::Any)
│        @ Core ./boot.jl:489
│     [22] include_string(mapexpr::typeof(identity), mod::Module, code::String, filename::String)
│        @ Base ./loading.jl:2918
│     [23] include_string
│        @ ./loading.jl:2928 [inlined]
│     [24] exec_options(opts::Base.JLOptions)
│        @ Base ./client.jl:328
│     [25] _start()
│        @ Base ./client.jl:563
│    during initialization of module API
│    in expression starting at /home/pkgeval/.julia/packages/Enzyme/ez9it/ext/EnzymeLogExpFunctionsExt.jl:1
│    in expression starting at stdin:
└ @ Base loading.jl:1591
Precompiling packages...
Info Given EnzymeChainRulesCoreExt was explicitly requested, output will be shown live 
ERROR: LoadError: InitError: UndefVarError: `libEnzyme` not defined in `Enzyme.API`
Suggestion: check for spelling errors or missing imports.
Stacktrace:
  [1] __init__()
    @ Enzyme.API ~/.julia/packages/Enzyme/ez9it/src/api.jl:1405
  [2] run_module_init(mod::Module, i::Int64)
    @ Base ./loading.jl:1417
  [3] register_restored_modules(sv::Core.SimpleVector, pkg::Base.PkgId, path::String)
    @ Base ./loading.jl:1405
  [4] _include_from_serialized(pkg::Base.PkgId, path::String, ocachepath::Nothing, depmods::Vector{Any}; register::Bool)
    @ Base ./loading.jl:1293
  [5] _include_from_serialized
    @ ./loading.jl:1247 [inlined]
  [6] _require_search_from_serialized(pkg::Base.PkgId, sourcepath::String, build_id::UInt128, stalecheck::Bool; reasons::Dict{String, Int64}, DEPOT_PATH::Vector{String})
    @ Base ./loading.jl:2105
  [7] _require_search_from_serialized
    @ ./loading.jl:1999 [inlined]
  [8] __require_prelocked(pkg::Base.PkgId, env::String)
    @ Base ./loading.jl:2649
  [9] _require_prelocked(uuidkey::Base.PkgId, env::String)
    @ Base ./loading.jl:2515
 [10] macro expansion
    @ ./loading.jl:2443 [inlined]
 [11] macro expansion
    @ ./lock.jl:376 [inlined]
 [12] __require(into::Module, mod::Symbol)
    @ Base ./loading.jl:2407
 [13] require
    @ ./loading.jl:2383 [inlined]
 [14] eval_import_path
    @ ./module.jl:36 [inlined]
 [15] eval_import_path_all(at::Module, path::Expr, keyword::String)
    @ Base ./module.jl:60
 [16] _eval_using(to::Module, path::Expr)
    @ Base ./module.jl:137
 [17] top-level scope
    @ ~/.julia/packages/Enzyme/ez9it/ext/EnzymeChainRulesCoreExt.jl:5
 [18] include(mod::Module, _path::String)
    @ Base ./Base.jl:308
 [19] include_package_for_output(pkg::Base.PkgId, input::String, depot_path::Vector{String}, dl_load_path::Vector{String}, load_path::Vector{String}, concrete_deps::Vector{Pair{Base.PkgId, UInt128}}, source::Nothing)
    @ Base ./loading.jl:3072
 [20] top-level scope
    @ stdin:5
 [21] eval(m::Module, e::Any)
    @ Core ./boot.jl:489
 [22] include_string(mapexpr::typeof(identity), mod::Module, code::String, filename::String)
    @ Base ./loading.jl:2918
 [23] include_string
    @ ./loading.jl:2928 [inlined]
 [24] exec_options(opts::Base.JLOptions)
    @ Base ./client.jl:328
 [25] _start()
    @ Base ./client.jl:563
during initialization of module API
in expression starting at /home/pkgeval/.julia/packages/Enzyme/ez9it/ext/EnzymeChainRulesCoreExt.jl:1
in expression starting at stdin:5
              ✗ Enzyme → EnzymeChainRulesCoreExt
  0 dependencies successfully precompiled in 16 seconds. 53 already precompiled.

┌ Error: Error during loading of extension EnzymeChainRulesCoreExt of Enzyme, use `Base.retry_load_extensions()` to retry.
│   exception =
│    1-element ExceptionStack:
│    The following 1 direct dependency failed to precompile:
│    
│    EnzymeChainRulesCoreExt 
│    
│    Failed to precompile EnzymeChainRulesCoreExt [dea36ce8-68cc-5ac3-8d54-6d6fec99b42c] to "/home/pkgeval/.julia/compiled/v1.13/EnzymeChainRulesCoreExt/jl_DN01f3" (ProcessExited(1)).
│    ERROR: LoadError: InitError: UndefVarError: `libEnzyme` not defined in `Enzyme.API`
│    Suggestion: check for spelling errors or missing imports.
│    Stacktrace:
│      [1] __init__()
│        @ Enzyme.API ~/.julia/packages/Enzyme/ez9it/src/api.jl:1405
│      [2] run_module_init(mod::Module, i::Int64)
│        @ Base ./loading.jl:1417
│      [3] register_restored_modules(sv::Core.SimpleVector, pkg::Base.PkgId, path::String)
│        @ Base ./loading.jl:1405
│      [4] _include_from_serialized(pkg::Base.PkgId, path::String, ocachepath::Nothing, depmods::Vector{Any}; register::Bool)
│        @ Base ./loading.jl:1293
│      [5] _include_from_serialized
│        @ ./loading.jl:1247 [inlined]
│      [6] _require_search_from_serialized(pkg::Base.PkgId, sourcepath::String, build_id::UInt128, stalecheck::Bool; reasons::Dict{String, Int64}, DEPOT_PATH::Vector{String})
│        @ Base ./loading.jl:2105
│      [7] _require_search_from_serialized
│        @ ./loading.jl:1999 [inlined]
│      [8] __require_prelocked(pkg::Base.PkgId, env::String)
│        @ Base ./loading.jl:2649
│      [9] _require_prelocked(uuidkey::Base.PkgId, env::String)
│        @ Base ./loading.jl:2515
│     [10] macro expansion
│        @ ./loading.jl:2443 [inlined]
│     [11] macro expansion
│        @ ./lock.jl:376 [inlined]
│     [12] __require(into::Module, mod::Symbol)
│        @ Base ./loading.jl:2407
│     [13] require
│        @ ./loading.jl:2383 [inlined]
│     [14] eval_import_path
│        @ ./module.jl:36 [inlined]
│     [15] eval_import_path_all(at::Module, path::Expr, keyword::String)
│        @ Base ./module.jl:60
│     [16] _eval_using(to::Module, path::Expr)
│        @ Base ./module.jl:137
│     [17] top-level scope
│        @ ~/.julia/packages/Enzyme/ez9it/ext/EnzymeChainRulesCoreExt.jl:5
│     [18] include(mod::Module, _path::String)
│        @ Base ./Base.jl:308
│     [19] include_package_for_output(pkg::Base.PkgId, input::String, depot_path::Vector{String}, dl_load_path::Vector{String}, load_path::Vector{String}, concrete_deps::Vector{Pair{Base.PkgId, UInt128}}, source::Nothing)
│        @ Base ./loading.jl:3072
│     [20] top-level scope
│        @ stdin:5
│     [21] eval(m::Module, e::Any)
│        @ Core ./boot.jl:489
│     [22] include_string(mapexpr::typeof(identity), mod::Module, code::String, filename::String)
│        @ Base ./loading.jl:2918
│     [23] include_string
│        @ ./loading.jl:2928 [inlined]
│     [24] exec_options(opts::Base.JLOptions)
│        @ Base ./client.jl:328
│     [25] _start()
│        @ Base ./client.jl:563
│    during initialization of module API
│    in expression starting at /home/pkgeval/.julia/packages/Enzyme/ez9it/ext/EnzymeChainRulesCoreExt.jl:1
│    in expression starting at stdin:
└ @ Base loading.jl:1591
Precompiling packages...
Info Given EnzymeGPUArraysCoreExt was explicitly requested, output will be shown live 
ERROR: LoadError: InitError: UndefVarError: `libEnzyme` not defined in `Enzyme.API`
Suggestion: check for spelling errors or missing imports.
Stacktrace:
  [1] __init__()
    @ Enzyme.API ~/.julia/packages/Enzyme/ez9it/src/api.jl:1405
  [2] run_module_init(mod::Module, i::Int64)
    @ Base ./loading.jl:1417
  [3] register_restored_modules(sv::Core.SimpleVector, pkg::Base.PkgId, path::String)
    @ Base ./loading.jl:1405
  [4] _include_from_serialized(pkg::Base.PkgId, path::String, ocachepath::Nothing, depmods::Vector{Any}; register::Bool)
    @ Base ./loading.jl:1293
  [5] _include_from_serialized
    @ ./loading.jl:1247 [inlined]
  [6] _require_search_from_serialized(pkg::Base.PkgId, sourcepath::String, build_id::UInt128, stalecheck::Bool; reasons::Dict{String, Int64}, DEPOT_PATH::Vector{String})
    @ Base ./loading.jl:2105
  [7] _require_search_from_serialized
    @ ./loading.jl:1999 [inlined]
  [8] __require_prelocked(pkg::Base.PkgId, env::String)
    @ Base ./loading.jl:2649
  [9] _require_prelocked(uuidkey::Base.PkgId, env::String)
    @ Base ./loading.jl:2515
 [10] macro expansion
    @ ./loading.jl:2443 [inlined]
 [11] macro expansion
    @ ./lock.jl:376 [inlined]
 [12] __require(into::Module, mod::Symbol)
    @ Base ./loading.jl:2407
 [13] require
    @ ./loading.jl:2383 [inlined]
 [14] eval_import_path
    @ ./module.jl:36 [inlined]
 [15] eval_import_path_all(at::Module, path::Expr, keyword::String)
    @ Base ./module.jl:60
 [16] _eval_using(to::Module, path::Expr)
    @ Base ./module.jl:137
 [17] top-level scope
    @ ~/.julia/packages/Enzyme/ez9it/ext/EnzymeGPUArraysCoreExt.jl:4
 [18] include(mod::Module, _path::String)
    @ Base ./Base.jl:308
 [19] include_package_for_output(pkg::Base.PkgId, input::String, depot_path::Vector{String}, dl_load_path::Vector{String}, load_path::Vector{String}, concrete_deps::Vector{Pair{Base.PkgId, UInt128}}, source::Nothing)
    @ Base ./loading.jl:3072
 [20] top-level scope
    @ stdin:5
 [21] eval(m::Module, e::Any)
    @ Core ./boot.jl:489
 [22] include_string(mapexpr::typeof(identity), mod::Module, code::String, filename::String)
    @ Base ./loading.jl:2918
 [23] include_string
    @ ./loading.jl:2928 [inlined]
 [24] exec_options(opts::Base.JLOptions)
    @ Base ./client.jl:328
 [25] _start()
    @ Base ./client.jl:563
during initialization of module API
in expression starting at /home/pkgeval/.julia/packages/Enzyme/ez9it/ext/EnzymeGPUArraysCoreExt.jl:1
in expression starting at stdin:5
              ✗ Enzyme → EnzymeGPUArraysCoreExt
  0 dependencies successfully precompiled in 15 seconds. 54 already precompiled.

┌ Error: Error during loading of extension EnzymeGPUArraysCoreExt of Enzyme, use `Base.retry_load_extensions()` to retry.
│   exception =
│    1-element ExceptionStack:
│    The following 1 direct dependency failed to precompile:
│    
│    EnzymeGPUArraysCoreExt 
│    
│    Failed to precompile EnzymeGPUArraysCoreExt [6f04138c-15cb-59c5-94f1-55440044fc8e] to "/home/pkgeval/.julia/compiled/v1.13/EnzymeGPUArraysCoreExt/jl_6cAcTc" (ProcessExited(1)).
│    ERROR: LoadError: InitError: UndefVarError: `libEnzyme` not defined in `Enzyme.API`
│    Suggestion: check for spelling errors or missing imports.
│    Stacktrace:
│      [1] __init__()
│        @ Enzyme.API ~/.julia/packages/Enzyme/ez9it/src/api.jl:1405
│      [2] run_module_init(mod::Module, i::Int64)
│        @ Base ./loading.jl:1417
│      [3] register_restored_modules(sv::Core.SimpleVector, pkg::Base.PkgId, path::String)
│        @ Base ./loading.jl:1405
│      [4] _include_from_serialized(pkg::Base.PkgId, path::String, ocachepath::Nothing, depmods::Vector{Any}; register::Bool)
│        @ Base ./loading.jl:1293
│      [5] _include_from_serialized
│        @ ./loading.jl:1247 [inlined]
│      [6] _require_search_from_serialized(pkg::Base.PkgId, sourcepath::String, build_id::UInt128, stalecheck::Bool; reasons::Dict{String, Int64}, DEPOT_PATH::Vector{String})
│        @ Base ./loading.jl:2105
│      [7] _require_search_from_serialized
│        @ ./loading.jl:1999 [inlined]
│      [8] __require_prelocked(pkg::Base.PkgId, env::String)
│        @ Base ./loading.jl:2649
│      [9] _require_prelocked(uuidkey::Base.PkgId, env::String)
│        @ Base ./loading.jl:2515
│     [10] macro expansion
│        @ ./loading.jl:2443 [inlined]
│     [11] macro expansion
│        @ ./lock.jl:376 [inlined]
│     [12] __require(into::Module, mod::Symbol)
│        @ Base ./loading.jl:2407
│     [13] require
│        @ ./loading.jl:2383 [inlined]
│     [14] eval_import_path
│        @ ./module.jl:36 [inlined]
│     [15] eval_import_path_all(at::Module, path::Expr, keyword::String)
│        @ Base ./module.jl:60
│     [16] _eval_using(to::Module, path::Expr)
│        @ Base ./module.jl:137
│     [17] top-level scope
│        @ ~/.julia/packages/Enzyme/ez9it/ext/EnzymeGPUArraysCoreExt.jl:4
│     [18] include(mod::Module, _path::String)
│        @ Base ./Base.jl:308
│     [19] include_package_for_output(pkg::Base.PkgId, input::String, depot_path::Vector{String}, dl_load_path::Vector{String}, load_path::Vector{String}, concrete_deps::Vector{Pair{Base.PkgId, UInt128}}, source::Nothing)
│        @ Base ./loading.jl:3072
│     [20] top-level scope
│        @ stdin:5
│     [21] eval(m::Module, e::Any)
│        @ Core ./boot.jl:489
│     [22] include_string(mapexpr::typeof(identity), mod::Module, code::String, filename::String)
│        @ Base ./loading.jl:2918
│     [23] include_string
│        @ ./loading.jl:2928 [inlined]
│     [24] exec_options(opts::Base.JLOptions)
│        @ Base ./client.jl:328
│     [25] _start()
│        @ Base ./client.jl:563
│    during initialization of module API
│    in expression starting at /home/pkgeval/.julia/packages/Enzyme/ez9it/ext/EnzymeGPUArraysCoreExt.jl:1
│    in expression starting at stdin:
└ @ Base loading.jl:1591
Precompiling packages...
Info Given EnzymeSpecialFunctionsExt was explicitly requested, output will be shown live 
ERROR: LoadError: InitError: UndefVarError: `libEnzyme` not defined in `Enzyme.API`
Suggestion: check for spelling errors or missing imports.
Stacktrace:
  [1] __init__()
    @ Enzyme.API ~/.julia/packages/Enzyme/ez9it/src/api.jl:1405
  [2] run_module_init(mod::Module, i::Int64)
    @ Base ./loading.jl:1417
  [3] register_restored_modules(sv::Core.SimpleVector, pkg::Base.PkgId, path::String)
    @ Base ./loading.jl:1405
  [4] _include_from_serialized(pkg::Base.PkgId, path::String, ocachepath::Nothing, depmods::Vector{Any}; register::Bool)
    @ Base ./loading.jl:1293
  [5] _include_from_serialized
    @ ./loading.jl:1247 [inlined]
  [6] _require_search_from_serialized(pkg::Base.PkgId, sourcepath::String, build_id::UInt128, stalecheck::Bool; reasons::Dict{String, Int64}, DEPOT_PATH::Vector{String})
    @ Base ./loading.jl:2105
  [7] _require_search_from_serialized
    @ ./loading.jl:1999 [inlined]
  [8] __require_prelocked(pkg::Base.PkgId, env::String)
    @ Base ./loading.jl:2649
  [9] _require_prelocked(uuidkey::Base.PkgId, env::String)
    @ Base ./loading.jl:2515
 [10] macro expansion
    @ ./loading.jl:2443 [inlined]
 [11] macro expansion
    @ ./lock.jl:376 [inlined]
 [12] __require(into::Module, mod::Symbol)
    @ Base ./loading.jl:2407
 [13] require
    @ ./loading.jl:2383 [inlined]
 [14] eval_import_path
    @ ./module.jl:36 [inlined]
 [15] eval_import_path_all(at::Module, path::Expr, keyword::String)
    @ Base ./module.jl:60
 [16] _eval_using(to::Module, path::Expr)
    @ Base ./module.jl:137
 [17] top-level scope
    @ ~/.julia/packages/Enzyme/ez9it/ext/EnzymeSpecialFunctionsExt.jl:4
 [18] include(mod::Module, _path::String)
    @ Base ./Base.jl:308
 [19] include_package_for_output(pkg::Base.PkgId, input::String, depot_path::Vector{String}, dl_load_path::Vector{String}, load_path::Vector{String}, concrete_deps::Vector{Pair{Base.PkgId, UInt128}}, source::Nothing)
    @ Base ./loading.jl:3072
 [20] top-level scope
    @ stdin:5
 [21] eval(m::Module, e::Any)
    @ Core ./boot.jl:489
 [22] include_string(mapexpr::typeof(identity), mod::Module, code::String, filename::String)
    @ Base ./loading.jl:2918
 [23] include_string
    @ ./loading.jl:2928 [inlined]
 [24] exec_options(opts::Base.JLOptions)
    @ Base ./client.jl:328
 [25] _start()
    @ Base ./client.jl:563
during initialization of module API
in expression starting at /home/pkgeval/.julia/packages/Enzyme/ez9it/ext/EnzymeSpecialFunctionsExt.jl:1
in expression starting at stdin:5
              ✗ Enzyme → EnzymeSpecialFunctionsExt
              ✗ Enzyme → EnzymeLogExpFunctionsExt
  0 dependencies successfully precompiled in 32 seconds. 55 already precompiled.

┌ Error: Error during loading of extension EnzymeSpecialFunctionsExt of Enzyme, use `Base.retry_load_extensions()` to retry.
│   exception =
│    1-element ExceptionStack:
│    The following 2 direct dependencies failed to precompile:
│    
│    EnzymeSpecialFunctionsExt 
│    
│    Failed to precompile EnzymeSpecialFunctionsExt [bc91e8c5-4631-5c58-9d34-c5da8b408cf1] to "/home/pkgeval/.julia/compiled/v1.13/EnzymeSpecialFunctionsExt/jl_jxTL7y" (ProcessExited(1)).
│    ERROR: LoadError: InitError: UndefVarError: `libEnzyme` not defined in `Enzyme.API`
│    Suggestion: check for spelling errors or missing imports.
│    Stacktrace:
│      [1] __init__()
│        @ Enzyme.API ~/.julia/packages/Enzyme/ez9it/src/api.jl:1405
│      [2] run_module_init(mod::Module, i::Int64)
│        @ Base ./loading.jl:1417
│      [3] register_restored_modules(sv::Core.SimpleVector, pkg::Base.PkgId, path::String)
│        @ Base ./loading.jl:1405
│      [4] _include_from_serialized(pkg::Base.PkgId, path::String, ocachepath::Nothing, depmods::Vector{Any}; register::Bool)
│        @ Base ./loading.jl:1293
│      [5] _include_from_serialized
│        @ ./loading.jl:1247 [inlined]
│      [6] _require_search_from_serialized(pkg::Base.PkgId, sourcepath::String, build_id::UInt128, stalecheck::Bool; reasons::Dict{String, Int64}, DEPOT_PATH::Vector{String})
│        @ Base ./loading.jl:2105
│      [7] _require_search_from_serialized
│        @ ./loading.jl:1999 [inlined]
│      [8] __require_prelocked(pkg::Base.PkgId, env::String)
│        @ Base ./loading.jl:2649
│      [9] _require_prelocked(uuidkey::Base.PkgId, env::String)
│        @ Base ./loading.jl:2515
│     [10] macro expansion
│        @ ./loading.jl:2443 [inlined]
│     [11] macro expansion
│        @ ./lock.jl:376 [inlined]
│     [12] __require(into::Module, mod::Symbol)
│        @ Base ./loading.jl:2407
│     [13] require
│        @ ./loading.jl:2383 [inlined]
│     [14] eval_import_path
│        @ ./module.jl:36 [inlined]
│     [15] eval_import_path_all(at::Module, path::Expr, keyword::String)
│        @ Base ./module.jl:60
│     [16] _eval_using(to::Module, path::Expr)
│        @ Base ./module.jl:137
│     [17] top-level scope
│        @ ~/.julia/packages/Enzyme/ez9it/ext/EnzymeSpecialFunctionsExt.jl:4
│     [18] include(mod::Module, _path::String)
│        @ Base ./Base.jl:308
│     [19] include_package_for_output(pkg::Base.PkgId, input::String, depot_path::Vector{String}, dl_load_path::Vector{String}, load_path::Vector{String}, concrete_deps::Vector{Pair{Base.PkgId, UInt128}}, source::Nothing)
│        @ Base ./loading.jl:3072
│     [20] top-level scope
│        @ stdin:5
│     [21] eval(m::Module, e::Any)
│        @ Core ./boot.jl:489
│     [22] include_string(mapexpr::typeof(identity), mod::Module, code::String, filename::String)
│        @ Base ./loading.jl:2918
│     [23] include_string
│        @ ./loading.jl:2928 [inlined]
│     [24] exec_options(opts::Base.JLOptions)
│        @ Base ./client.jl:328
│     [25] _start()
│        @ Base ./client.jl:563
│    during initialization of module API
│    in expression starting at /home/pkgeval/.julia/packages/Enzyme/ez9it/ext/EnzymeSpecialFunctionsExt.jl:1
│    in expression starting at stdin:5
│    EnzymeLogExpFunctionsExt 
│    
│    Failed to precompile EnzymeLogExpFunctionsExt [1a9f04a6-12b6-5435-a00e-55b0a0022015] to "/home/pkgeval/.julia/compiled/v1.13/EnzymeLogExpFunctionsExt/jl_HXYG84" (ProcessExited(1)).
│    ERROR: LoadError: InitError: UndefVarError: `libEnzyme` not defined in `Enzyme.API`
│    Suggestion: check for spelling errors or missing imports.
│    Stacktrace:
│      [1] __init__()
│        @ Enzyme.API ~/.julia/packages/Enzyme/ez9it/src/api.jl:1405
│      [2] run_module_init(mod::Module, i::Int64)
│        @ Base ./loading.jl:1417
│      [3] register_restored_modules(sv::Core.SimpleVector, pkg::Base.PkgId, path::String)
│        @ Base ./loading.jl:1405
│      [4] _include_from_serialized(pkg::Base.PkgId, path::String, ocachepath::Nothing, depmods::Vector{Any}; register::Bool)
│        @ Base ./loading.jl:1293
│      [5] _include_from_serialized
│        @ ./loading.jl:1247 [inlined]
│      [6] _require_search_from_serialized(pkg::Base.PkgId, sourcepath::String, build_id::UInt128, stalecheck::Bool; reasons::Dict{String, Int64}, DEPOT_PATH::Vector{String})
│        @ Base ./loading.jl:2105
│      [7] _require_search_from_serialized
│        @ ./loading.jl:1999 [inlined]
│      [8] __require_prelocked(pkg::Base.PkgId, env::String)
│        @ Base ./loading.jl:2649
│      [9] _require_prelocked(uuidkey::Base.PkgId, env::String)
│        @ Base ./loading.jl:2515
│     [10] macro expansion
│        @ ./loading.jl:2443 [inlined]
│     [11] macro expansion
│        @ ./lock.jl:376 [inlined]
│     [12] __require(into::Module, mod::Symbol)
│        @ Base ./loading.jl:2407
│     [13] require
│        @ ./loading.jl:2383 [inlined]
│     [14] eval_import_path
│        @ ./module.jl:36 [inlined]
│     [15] eval_import_path_all(at::Module, path::Expr, keyword::String)
│        @ Base ./module.jl:60
│     [16] _eval_using(to::Module, path::Expr)
│        @ Base ./module.jl:137
│     [17] top-level scope
│        @ ~/.julia/packages/Enzyme/ez9it/ext/EnzymeLogExpFunctionsExt.jl:4
│     [18] include(mod::Module, _path::String)
│        @ Base ./Base.jl:308
│     [19] include_package_for_output(pkg::Base.PkgId, input::String, depot_path::Vector{String}, dl_load_path::Vector{String}, load_path::Vector{String}, concrete_deps::Vector{Pair{Base.PkgId, UInt128}}, source::Nothing)
│        @ Base ./loading.jl:3072
│     [20] top-level scope
│        @ stdin:5
│     [21] eval(m::Module, e::Any)
│        @ Core ./boot.jl:489
│     [22] include_string(mapexpr::typeof(identity), mod::Module, code::String, filename::String)
│        @ Base ./loading.jl:2918
│     [23] include_string
│        @ ./loading.jl:2928 [inlined]
│     [24] exec_options(opts::Base.JLOptions)
│        @ Base ./client.jl:328
│     [25] _start()
│        @ Base ./client.jl:563
│    during initialization of module API
│    in expression starting at /home/pkgeval/.julia/packages/Enzyme/ez9it/ext/EnzymeLogExpFunctionsExt.jl:1
│    in expression starting at stdin:5
└ @ Base loading.jl:1591
Precompiling packages...
Info Given EnzymeStaticArraysExt was explicitly requested, output will be shown live 
ERROR: LoadError: InitError: UndefVarError: `libEnzyme` not defined in `Enzyme.API`
Suggestion: check for spelling errors or missing imports.
Stacktrace:
  [1] __init__()
    @ Enzyme.API ~/.julia/packages/Enzyme/ez9it/src/api.jl:1405
  [2] run_module_init(mod::Module, i::Int64)
    @ Base ./loading.jl:1417
  [3] register_restored_modules(sv::Core.SimpleVector, pkg::Base.PkgId, path::String)
    @ Base ./loading.jl:1405
  [4] _include_from_serialized(pkg::Base.PkgId, path::String, ocachepath::Nothing, depmods::Vector{Any}; register::Bool)
    @ Base ./loading.jl:1293
  [5] _include_from_serialized
    @ ./loading.jl:1247 [inlined]
  [6] _require_search_from_serialized(pkg::Base.PkgId, sourcepath::String, build_id::UInt128, stalecheck::Bool; reasons::Dict{String, Int64}, DEPOT_PATH::Vector{String})
    @ Base ./loading.jl:2105
  [7] _require_search_from_serialized
    @ ./loading.jl:1999 [inlined]
  [8] __require_prelocked(pkg::Base.PkgId, env::String)
    @ Base ./loading.jl:2649
  [9] _require_prelocked(uuidkey::Base.PkgId, env::String)
    @ Base ./loading.jl:2515
 [10] macro expansion
    @ ./loading.jl:2443 [inlined]
 [11] macro expansion
    @ ./lock.jl:376 [inlined]
 [12] __require(into::Module, mod::Symbol)
    @ Base ./loading.jl:2407
 [13] require
    @ ./loading.jl:2383 [inlined]
 [14] eval_import_path
    @ ./module.jl:36 [inlined]
 [15] eval_import_path_all(at::Module, path::Expr, keyword::String)
    @ Base ./module.jl:60
 [16] _eval_using(to::Module, path::Expr)
    @ Base ./module.jl:137
 [17] top-level scope
    @ ~/.julia/packages/Enzyme/ez9it/ext/EnzymeStaticArraysExt.jl:4
 [18] include(mod::Module, _path::String)
    @ Base ./Base.jl:308
 [19] include_package_for_output(pkg::Base.PkgId, input::String, depot_path::Vector{String}, dl_load_path::Vector{String}, load_path::Vector{String}, concrete_deps::Vector{Pair{Base.PkgId, UInt128}}, source::Nothing)
    @ Base ./loading.jl:3072
 [20] top-level scope
    @ stdin:5
 [21] eval(m::Module, e::Any)
    @ Core ./boot.jl:489
 [22] include_string(mapexpr::typeof(identity), mod::Module, code::String, filename::String)
    @ Base ./loading.jl:2918
 [23] include_string
    @ ./loading.jl:2928 [inlined]
 [24] exec_options(opts::Base.JLOptions)
    @ Base ./client.jl:328
 [25] _start()
    @ Base ./client.jl:563
during initialization of module API
in expression starting at /home/pkgeval/.julia/packages/Enzyme/ez9it/ext/EnzymeStaticArraysExt.jl:1
in expression starting at stdin:5
              ✗ Enzyme → EnzymeStaticArraysExt
  0 dependencies successfully precompiled in 18 seconds. 51 already precompiled.

┌ Error: Error during loading of extension EnzymeStaticArraysExt of Enzyme, use `Base.retry_load_extensions()` to retry.
│   exception =
│    1-element ExceptionStack:
│    The following 1 direct dependency failed to precompile:
│    
│    EnzymeStaticArraysExt 
│    
│    Failed to precompile EnzymeStaticArraysExt [8724f06c-f4c4-5d10-8ca5-5036e220244b] to "/home/pkgeval/.julia/compiled/v1.13/EnzymeStaticArraysExt/jl_crNspg" (ProcessExited(1)).
│    ERROR: LoadError: InitError: UndefVarError: `libEnzyme` not defined in `Enzyme.API`
│    Suggestion: check for spelling errors or missing imports.
│    Stacktrace:
│      [1] __init__()
│        @ Enzyme.API ~/.julia/packages/Enzyme/ez9it/src/api.jl:1405
│      [2] run_module_init(mod::Module, i::Int64)
│        @ Base ./loading.jl:1417
│      [3] register_restored_modules(sv::Core.SimpleVector, pkg::Base.PkgId, path::String)
│        @ Base ./loading.jl:1405
│      [4] _include_from_serialized(pkg::Base.PkgId, path::String, ocachepath::Nothing, depmods::Vector{Any}; register::Bool)
│        @ Base ./loading.jl:1293
│      [5] _include_from_serialized
│        @ ./loading.jl:1247 [inlined]
│      [6] _require_search_from_serialized(pkg::Base.PkgId, sourcepath::String, build_id::UInt128, stalecheck::Bool; reasons::Dict{String, Int64}, DEPOT_PATH::Vector{String})
│        @ Base ./loading.jl:2105
│      [7] _require_search_from_serialized
│        @ ./loading.jl:1999 [inlined]
│      [8] __require_prelocked(pkg::Base.PkgId, env::String)
│        @ Base ./loading.jl:2649
│      [9] _require_prelocked(uuidkey::Base.PkgId, env::String)
│        @ Base ./loading.jl:2515
│     [10] macro expansion
│        @ ./loading.jl:2443 [inlined]
│     [11] macro expansion
│        @ ./lock.jl:376 [inlined]
│     [12] __require(into::Module, mod::Symbol)
│        @ Base ./loading.jl:2407
│     [13] require
│        @ ./loading.jl:2383 [inlined]
│     [14] eval_import_path
│        @ ./module.jl:36 [inlined]
│     [15] eval_import_path_all(at::Module, path::Expr, keyword::String)
│        @ Base ./module.jl:60
│     [16] _eval_using(to::Module, path::Expr)
│        @ Base ./module.jl:137
│     [17] top-level scope
│        @ ~/.julia/packages/Enzyme/ez9it/ext/EnzymeStaticArraysExt.jl:4
│     [18] include(mod::Module, _path::String)
│        @ Base ./Base.jl:308
│     [19] include_package_for_output(pkg::Base.PkgId, input::String, depot_path::Vector{String}, dl_load_path::Vector{String}, load_path::Vector{String}, concrete_deps::Vector{Pair{Base.PkgId, UInt128}}, source::Nothing)
│        @ Base ./loading.jl:3072
│     [20] top-level scope
│        @ stdin:5
│     [21] eval(m::Module, e::Any)
│        @ Core ./boot.jl:489
│     [22] include_string(mapexpr::typeof(identity), mod::Module, code::String, filename::String)
│        @ Base ./loading.jl:2918
│     [23] include_string
│        @ ./loading.jl:2928 [inlined]
│     [24] exec_options(opts::Base.JLOptions)
│        @ Base ./client.jl:328
│     [25] _start()
│        @ Base ./client.jl:563
│    during initialization of module API
│    in expression starting at /home/pkgeval/.julia/packages/Enzyme/ez9it/ext/EnzymeStaticArraysExt.jl:1
│    in expression starting at stdin:
└ @ Base loading.jl:1591
Precompiling packages...
Info Given DifferentiationInterfaceEnzymeExt was explicitly requested, output will be shown live 
ERROR: LoadError: InitError: UndefVarError: `libEnzyme` not defined in `Enzyme.API`
Suggestion: check for spelling errors or missing imports.
Stacktrace:
  [1] __init__()
    @ Enzyme.API ~/.julia/packages/Enzyme/ez9it/src/api.jl:1405
  [2] run_module_init(mod::Module, i::Int64)
    @ Base ./loading.jl:1417
  [3] register_restored_modules(sv::Core.SimpleVector, pkg::Base.PkgId, path::String)
    @ Base ./loading.jl:1405
  [4] _include_from_serialized(pkg::Base.PkgId, path::String, ocachepath::Nothing, depmods::Vector{Any}; register::Bool)
    @ Base ./loading.jl:1293
  [5] _include_from_serialized
    @ ./loading.jl:1247 [inlined]
  [6] _require_search_from_serialized(pkg::Base.PkgId, sourcepath::String, build_id::UInt128, stalecheck::Bool; reasons::Dict{String, Int64}, DEPOT_PATH::Vector{String})
    @ Base ./loading.jl:2105
  [7] _require_search_from_serialized
    @ ./loading.jl:1999 [inlined]
  [8] __require_prelocked(pkg::Base.PkgId, env::String)
    @ Base ./loading.jl:2649
  [9] _require_prelocked(uuidkey::Base.PkgId, env::String)
    @ Base ./loading.jl:2515
 [10] macro expansion
    @ ./loading.jl:2443 [inlined]
 [11] macro expansion
    @ ./lock.jl:376 [inlined]
 [12] __require(into::Module, mod::Symbol)
    @ Base ./loading.jl:2407
 [13] require
    @ ./loading.jl:2383 [inlined]
 [14] eval_import_path
    @ ./module.jl:36 [inlined]
 [15] eval_import_path_all(at::Module, path::Expr, keyword::String)
    @ Base ./module.jl:60
 [16] _eval_import(::Bool, ::Module, ::Expr, ::Expr, ::Vararg{Expr})
    @ Base ./module.jl:101
 [17] top-level scope
    @ ~/.julia/packages/DifferentiationInterface/zJHX8/ext/DifferentiationInterfaceEnzymeExt/DifferentiationInterfaceEnzymeExt.jl:32
 [18] include(mod::Module, _path::String)
    @ Base ./Base.jl:308
 [19] include_package_for_output(pkg::Base.PkgId, input::String, depot_path::Vector{String}, dl_load_path::Vector{String}, load_path::Vector{String}, concrete_deps::Vector{Pair{Base.PkgId, UInt128}}, source::Nothing)
    @ Base ./loading.jl:3072
 [20] top-level scope
    @ stdin:5
 [21] eval(m::Module, e::Any)
    @ Core ./boot.jl:489
 [22] include_string(mapexpr::typeof(identity), mod::Module, code::String, filename::String)
    @ Base ./loading.jl:2918
 [23] include_string
    @ ./loading.jl:2928 [inlined]
 [24] exec_options(opts::Base.JLOptions)
    @ Base ./client.jl:328
 [25] _start()
    @ Base ./client.jl:563
during initialization of module API
in expression starting at /home/pkgeval/.julia/packages/DifferentiationInterface/zJHX8/ext/DifferentiationInterfaceEnzymeExt/DifferentiationInterfaceEnzymeExt.jl:1
in expression starting at stdin:5
              ✗ DifferentiationInterface → DifferentiationInterfaceEnzymeExt
  0 dependencies successfully precompiled in 16 seconds. 53 already precompiled.
ERROR: LoadError: InitError: UndefVarError: `libEnzyme` not defined in `Enzyme.API`
Suggestion: check for spelling errors or missing imports.
Stacktrace:
  [1] __init__()
    @ Enzyme.API ~/.julia/packages/Enzyme/ez9it/src/api.jl:1405
  [2] run_module_init(mod::Module, i::Int64)
    @ Base ./loading.jl:1417
  [3] register_restored_modules(sv::Core.SimpleVector, pkg::Base.PkgId, path::String)
    @ Base ./loading.jl:1405
  [4] _include_from_serialized(pkg::Base.PkgId, path::String, ocachepath::Nothing, depmods::Vector{Any}; register::Bool)
    @ Base ./loading.jl:1293
  [5] _include_from_serialized
    @ ./loading.jl:1247 [inlined]
  [6] _require_search_from_serialized(pkg::Base.PkgId, sourcepath::String, build_id::UInt128, stalecheck::Bool; reasons::Dict{String, Int64}, DEPOT_PATH::Vector{String})
    @ Base ./loading.jl:2105
  [7] _require_search_from_serialized
    @ ./loading.jl:1999 [inlined]
  [8] __require_prelocked(pkg::Base.PkgId, env::String)
    @ Base ./loading.jl:2649
  [9] _require_prelocked(uuidkey::Base.PkgId, env::String)
    @ Base ./loading.jl:2515
 [10] macro expansion
    @ ./loading.jl:2443 [inlined]
 [11] macro expansion
    @ ./lock.jl:376 [inlined]
 [12] __require(into::Module, mod::Symbol)
    @ Base ./loading.jl:2407
 [13] require
    @ ./loading.jl:2383 [inlined]
 [14] eval_import_path
    @ ./module.jl:36 [inlined]
 [15] eval_import_path_all(at::Module, path::Expr, keyword::String)
    @ Base ./module.jl:60
 [16] _eval_import(::Bool, ::Module, ::Expr, ::Expr, ::Vararg{Expr})
    @ Base ./module.jl:101
 [17] top-level scope
    @ ~/.julia/packages/DifferentiationInterface/zJHX8/ext/DifferentiationInterfaceEnzymeExt/DifferentiationInterfaceEnzymeExt.jl:32
 [18] include(mod::Module, _path::String)
    @ Base ./Base.jl:308
 [19] include_package_for_output(pkg::Base.PkgId, input::String, depot_path::Vector{String}, dl_load_path::Vector{String}, load_path::Vector{String}, concrete_deps::Vector{Pair{Base.PkgId, UInt128}}, source::String)
    @ Base ./loading.jl:3072
 [20] top-level scope
    @ stdin:5
 [21] eval(m::Module, e::Any)
    @ Core ./boot.jl:489
 [22] include_string(mapexpr::typeof(identity), mod::Module, code::String, filename::String)
    @ Base ./loading.jl:2918
 [23] include_string
    @ ./loading.jl:2928 [inlined]
 [24] exec_options(opts::Base.JLOptions)
    @ Base ./client.jl:328
 [25] _start()
    @ Base ./client.jl:563
during initialization of module API
in expression starting at /home/pkgeval/.julia/packages/DifferentiationInterface/zJHX8/ext/DifferentiationInterfaceEnzymeExt/DifferentiationInterfaceEnzymeExt.jl:1
in expression starting at stdin:5
┌ Error: Error during loading of extension DifferentiationInterfaceEnzymeExt of DifferentiationInterface, use `Base.retry_load_extensions()` to retry.
│   exception =
│    1-element ExceptionStack:
│    Failed to precompile DifferentiationInterfaceEnzymeExt [b2bef6f4-9359-51c0-9eac-bc8d0bbb8621] to "/home/pkgeval/.julia/compiled/v1.13/DifferentiationInterfaceEnzymeExt/jl_JlqNIz" (ProcessExited(1)).
│    Stacktrace:
│      [1] error(s::String)
│        @ Base ./error.jl:44
│      [2] compilecache(pkg::Base.PkgId, path::String, internal_stderr::IO, internal_stdout::IO, keep_loaded_modules::Bool; flags::Cmd, cacheflags::Base.CacheFlags, reasons::Dict{String, Int64}, loadable_exts::Vector{Base.PkgId})
│        @ Base ./loading.jl:3359
│      [3] kwcall(::@NamedTuple{reasons::Dict{String, Int64}, loadable_exts::Vector{Base.PkgId}}, ::typeof(Base.compilecache), pkg::Base.PkgId, path::String, internal_stderr::IO, internal_stdout::IO, keep_loaded_modules::Bool)
│        @ Base ./loading.jl:3237
│      [4] (::Base.var"#__require_prelocked##0#__require_prelocked##1"{Base.PkgId, String, Dict{String, Int64}})()
│        @ Base ./loading.jl:2701
│      [5] mkpidlock(f::Base.var"#__require_prelocked##0#__require_prelocked##1"{Base.PkgId, String, Dict{String, Int64}}, at::String, pid::Int32; kwopts::@Kwargs{stale_age::Int64, wait::Bool})
│        @ FileWatching.Pidfile /opt/julia/share/julia/stdlib/v1.13/FileWatching/src/pidfile.jl:94
│      [6] #mkpidlock#7
│        @ /opt/julia/share/julia/stdlib/v1.13/FileWatching/src/pidfile.jl:89 [inlined]
│      [7] trymkpidlock(::Function, ::Vararg{Any}; kwargs::@Kwargs{stale_age::Int64})
│        @ FileWatching.Pidfile /opt/julia/share/julia/stdlib/v1.13/FileWatching/src/pidfile.jl:115
│      [8] #invokelatest_gr#234
│        @ ./reflection.jl:1335 [inlined]
│      [9] invokelatest_gr
│        @ ./reflection.jl:1327 [inlined]
│     [10] maybe_cachefile_lock(f::Base.var"#__require_prelocked##0#__require_prelocked##1"{Base.PkgId, String, Dict{String, Int64}}, pkg::Base.PkgId, srcpath::String; stale_age::Int64)
│        @ Base ./loading.jl:3930
│     [11] maybe_cachefile_lock
│        @ ./loading.jl:3927 [inlined]
│     [12] __require_prelocked(pkg::Base.PkgId, env::Nothing)
│        @ Base ./loading.jl:2687
│     [13] _require_prelocked(uuidkey::Base.PkgId, env::Nothing)
│        @ Base ./loading.jl:2515
│     [14] _require_prelocked
│        @ ./loading.jl:2509 [inlined]
│     [15] run_extension_callbacks(extid::Base.ExtensionId)
│        @ Base ./loading.jl:1581
│     [16] run_extension_callbacks(pkgid::Base.PkgId)
│        @ Base ./loading.jl:1618
│     [17] run_package_callbacks(modkey::Base.PkgId)
│        @ Base ./loading.jl:1434
│     [18] _require_prelocked(uuidkey::Base.PkgId, env::String)
│        @ Base ./loading.jl:2523
│     [19] macro expansion
│        @ ./loading.jl:2443 [inlined]
│     [20] macro expansion
│        @ ./lock.jl:376 [inlined]
│     [21] __require(into::Module, mod::Symbol)
│        @ Base ./loading.jl:2407
│     [22] require
│        @ ./loading.jl:2383 [inlined]
│     [23] eval_import_path
│        @ ./module.jl:36 [inlined]
│     [24] eval_import_path_all(at::Module, path::Expr, keyword::String)
│        @ Base ./module.jl:60
│     [25] _eval_import(::Bool, ::Module, ::Expr, ::Expr, ::Vararg{Expr})
│        @ Base ./module.jl:101
│     [26] top-level scope
│        @ ~/.julia/packages/OpenMDAOCore/v5KNT/test/autosparse_automatic.jl:11
│     [27] include(mapexpr::Function, mod::Module, _path::String)
│        @ Base ./Base.jl:309
│     [28] top-level scope
│        @ ~/.julia/packages/SafeTestsets/raUNr/src/SafeTestsets.jl:681
│     [29] macro expansion
│        @ /opt/julia/share/julia/stdlib/v1.13/Test/src/Test.jl:1952 [inlined]
│     [30] macro expansion
│        @ ~/.julia/packages/OpenMDAOCore/v5KNT/test/runtests.jl:681 [inlined]
│     [31] eval(m::Module, e::Any)
│        @ Core ./boot.jl:489
│     [32] top-level scope
│        @ ~/.julia/packages/OpenMDAOCore/v5KNT/test/runtests.jl:677
│     [33] macro expansion
│        @ /opt/julia/share/julia/stdlib/v1.13/Test/src/Test.jl:1952 [inlined]
│     [34] macro expansion
│        @ ~/.julia/packages/OpenMDAOCore/v5KNT/test/runtests.jl:680 [inlined]
│     [35] macro expansion
│        @ ~/.julia/packages/SafeTestsets/raUNr/src/SafeTestsets.jl:28 [inlined]
│     [36] include(mapexpr::Function, mod::Module, _path::String)
│        @ Base ./Base.jl:309
│     [37] top-level scope
│        @ none:6
│     [38] eval(m::Module, e::Any)
│        @ Core ./boot.jl:489
│     [39] exec_options(opts::Base.JLOptions)
│        @ Base ./client.jl:296
│     [40] _start()
│        @ Base ./client.jl:563
└ @ Base loading.jl:1591

automatic sparsity: Error During Test at /home/pkgeval/.julia/packages/SafeTestsets/raUNr/src/SafeTestsets.jl:30
  Got exception outside of a @test
  LoadError: MethodError: no method matching _prepare_pushforward_aux(::Val{false}, ::DifferentiationInterface.PushforwardFast, ::OpenMDAOCore.var"#36#37"{typeof(Main.var"##automatic sparsity#190".f_simple!), Tuple{Int64, Int64}}, ::ComponentArrays.ComponentVector{Float64, Vector{Float64}, Tuple{ComponentArrays.Axis{(e = ViewAxis(1:3, Shaped1DAxis((3,))), f = ViewAxis(4:15, ShapedAxis((4, 3))), g = ViewAxis(16:27, ShapedAxis((3, 4))))}}}, ::ADTypes.AutoEnzyme{EnzymeCore.ForwardMode{false, EnzymeCore.FFIABI, false, false, false}, Nothing}, ::ComponentArrays.ComponentVector{Float64, Vector{Float64}, Tuple{ComponentArrays.Axis{(a = 1, b = ViewAxis(2:4, Shaped1DAxis((3,))), c = ViewAxis(5:8, Shaped1DAxis((4,))), d = ViewAxis(9:20, ShapedAxis((4, 3))))}}}, ::Tuple{ComponentArrays.ComponentVector{Float64, Vector{Float64}, Tuple{ComponentArrays.Axis{(a = 1, b = ViewAxis(2:4, Shaped1DAxis((3,))), c = ViewAxis(5:8, Shaped1DAxis((4,))), d = ViewAxis(9:20, ShapedAxis((4, 3))))}}}})
  The function `_prepare_pushforward_aux` exists, but no method is defined for this combination of argument types.
  The autodiff backend you chose may not be compatible with the operation you want to perform. Please refer to the documentation of DifferentiationInterface.jl and open an issue if necessary.
  Closest candidates are:
    _prepare_pushforward_aux(::Val, !Matched::DifferentiationInterface.PushforwardSlow, ::F, ::Any, ::ADTypes.AbstractADType, ::Any, ::NTuple{N, T} where {N, T}, DifferentiationInterface.Context...) where {F, C}
     @ DifferentiationInterface ~/.julia/packages/DifferentiationInterface/zJHX8/src/first_order/pushforward.jl:293
    _prepare_pushforward_aux(::Val, !Matched::DifferentiationInterface.PushforwardSlow, ::F, !Matched::ADTypes.AbstractADType, ::Any, !Matched::NTuple{N, T} where {N, T}, !Matched::DifferentiationInterface.Context...) where {F, C}
     @ DifferentiationInterface ~/.julia/packages/DifferentiationInterface/zJHX8/src/first_order/pushforward.jl:277
  Stacktrace:
    [1] prepare_pushforward_nokwarg(::Val{false}, ::OpenMDAOCore.var"#36#37"{typeof(Main.var"##automatic sparsity#190".f_simple!), Tuple{Int64, Int64}}, ::ComponentArrays.ComponentVector{Float64, Vector{Float64}, Tuple{ComponentArrays.Axis{(e = ViewAxis(1:3, Shaped1DAxis((3,))), f = ViewAxis(4:15, ShapedAxis((4, 3))), g = ViewAxis(16:27, ShapedAxis((3, 4))))}}}, ::ADTypes.AutoEnzyme{EnzymeCore.ForwardMode{false, EnzymeCore.FFIABI, false, false, false}, Nothing}, ::ComponentArrays.ComponentVector{Float64, Vector{Float64}, Tuple{ComponentArrays.Axis{(a = 1, b = ViewAxis(2:4, Shaped1DAxis((3,))), c = ViewAxis(5:8, Shaped1DAxis((4,))), d = ViewAxis(9:20, ShapedAxis((4, 3))))}}}, ::Tuple{ComponentArrays.ComponentVector{Float64, Vector{Float64}, Tuple{ComponentArrays.Axis{(a = 1, b = ViewAxis(2:4, Shaped1DAxis((3,))), c = ViewAxis(5:8, Shaped1DAxis((4,))), d = ViewAxis(9:20, ShapedAxis((4, 3))))}}}})
      @ DifferentiationInterface ~/.julia/packages/DifferentiationInterface/zJHX8/src/first_order/pushforward.jl:272
    [2] _prepare_sparse_jacobian_aux_aux(::Val{false}, ::DifferentiationInterface.BatchSizeSettings{1, false, true}, ::SparseArrays.SparseMatrixCSC{Bool, Int64}, ::SparseMatrixColorings.ColumnColoringResult{SparseArrays.SparseMatrixCSC{Bool, Int64}, Int64, SparseMatrixColorings.BipartiteGraph{Int64}, Vector{Int64}, Vector{SubArray{Int64, 1, Vector{Int64}, Tuple{UnitRange{Int64}}, true}}, Vector{Int64}, Nothing}, ::ComponentArrays.ComponentVector{Float64, Vector{Float64}, Tuple{ComponentArrays.Axis{(e = ViewAxis(1:3, Shaped1DAxis((3,))), f = ViewAxis(4:15, ShapedAxis((4, 3))), g = ViewAxis(16:27, ShapedAxis((3, 4))))}}}, ::Tuple{OpenMDAOCore.var"#36#37"{typeof(Main.var"##automatic sparsity#190".f_simple!), Tuple{Int64, Int64}}, ComponentArrays.ComponentVector{Float64, Vector{Float64}, Tuple{ComponentArrays.Axis{(e = ViewAxis(1:3, Shaped1DAxis((3,))), f = ViewAxis(4:15, ShapedAxis((4, 3))), g = ViewAxis(16:27, ShapedAxis((3, 4))))}}}}, ::ADTypes.AutoSparse{ADTypes.AutoEnzyme{EnzymeCore.ForwardMode{false, EnzymeCore.FFIABI, false, false, false}, Nothing}, OpenMDAOCore.PerturbedDenseSparsityDetector{:direct, ADTypes.AutoForwardDiff{nothing, Nothing}, Float64, Float64}, SparseMatrixColorings.GreedyColoringAlgorithm{:direct, SparseMatrixColorings.NaturalOrder}}, ::ComponentArrays.ComponentVector{Float64, Vector{Float64}, Tuple{ComponentArrays.Axis{(a = 1, b = ViewAxis(2:4, Shaped1DAxis((3,))), c = ViewAxis(5:8, Shaped1DAxis((4,))), d = ViewAxis(9:20, ShapedAxis((4, 3))))}}})
      @ DifferentiationInterfaceSparseMatrixColoringsExt ~/.julia/packages/DifferentiationInterface/zJHX8/ext/DifferentiationInterfaceSparseMatrixColoringsExt/jacobian.jl:124
    [3] _prepare_sparse_jacobian_aux(::Val{false}, ::DifferentiationInterface.PushforwardFast, ::ComponentArrays.ComponentVector{Float64, Vector{Float64}, Tuple{ComponentArrays.Axis{(e = ViewAxis(1:3, Shaped1DAxis((3,))), f = ViewAxis(4:15, ShapedAxis((4, 3))), g = ViewAxis(16:27, ShapedAxis((3, 4))))}}}, ::Tuple{OpenMDAOCore.var"#36#37"{typeof(Main.var"##automatic sparsity#190".f_simple!), Tuple{Int64, Int64}}, ComponentArrays.ComponentVector{Float64, Vector{Float64}, Tuple{ComponentArrays.Axis{(e = ViewAxis(1:3, Shaped1DAxis((3,))), f = ViewAxis(4:15, ShapedAxis((4, 3))), g = ViewAxis(16:27, ShapedAxis((3, 4))))}}}}, ::ADTypes.AutoSparse{ADTypes.AutoEnzyme{EnzymeCore.ForwardMode{false, EnzymeCore.FFIABI, false, false, false}, Nothing}, OpenMDAOCore.PerturbedDenseSparsityDetector{:direct, ADTypes.AutoForwardDiff{nothing, Nothing}, Float64, Float64}, SparseMatrixColorings.GreedyColoringAlgorithm{:direct, SparseMatrixColorings.NaturalOrder}}, ::ComponentArrays.ComponentVector{Float64, Vector{Float64}, Tuple{ComponentArrays.Axis{(a = 1, b = ViewAxis(2:4, Shaped1DAxis((3,))), c = ViewAxis(5:8, Shaped1DAxis((4,))), d = ViewAxis(9:20, ShapedAxis((4, 3))))}}})
      @ DifferentiationInterfaceSparseMatrixColoringsExt ~/.julia/packages/DifferentiationInterface/zJHX8/ext/DifferentiationInterfaceSparseMatrixColoringsExt/jacobian.jl:90
    [4] prepare_jacobian_nokwarg(::Val{false}, ::OpenMDAOCore.var"#36#37"{typeof(Main.var"##automatic sparsity#190".f_simple!), Tuple{Int64, Int64}}, ::ComponentArrays.ComponentVector{Float64, Vector{Float64}, Tuple{ComponentArrays.Axis{(e = ViewAxis(1:3, Shaped1DAxis((3,))), f = ViewAxis(4:15, ShapedAxis((4, 3))), g = ViewAxis(16:27, ShapedAxis((3, 4))))}}}, ::ADTypes.AutoSparse{ADTypes.AutoEnzyme{EnzymeCore.ForwardMode{false, EnzymeCore.FFIABI, false, false, false}, Nothing}, OpenMDAOCore.PerturbedDenseSparsityDetector{:direct, ADTypes.AutoForwardDiff{nothing, Nothing}, Float64, Float64}, SparseMatrixColorings.GreedyColoringAlgorithm{:direct, SparseMatrixColorings.NaturalOrder}}, ::ComponentArrays.ComponentVector{Float64, Vector{Float64}, Tuple{ComponentArrays.Axis{(a = 1, b = ViewAxis(2:4, Shaped1DAxis((3,))), c = ViewAxis(5:8, Shaped1DAxis((4,))), d = ViewAxis(9:20, ShapedAxis((4, 3))))}}})
      @ DifferentiationInterfaceSparseMatrixColoringsExt ~/.julia/packages/DifferentiationInterface/zJHX8/ext/DifferentiationInterfaceSparseMatrixColoringsExt/jacobian.jl:57
    [5] prepare_jacobian(::OpenMDAOCore.var"#36#37"{typeof(Main.var"##automatic sparsity#190".f_simple!), Tuple{Int64, Int64}}, ::ComponentArrays.ComponentVector{Float64, Vector{Float64}, Tuple{ComponentArrays.Axis{(e = ViewAxis(1:3, Shaped1DAxis((3,))), f = ViewAxis(4:15, ShapedAxis((4, 3))), g = ViewAxis(16:27, ShapedAxis((3, 4))))}}}, ::ADTypes.AutoSparse{ADTypes.AutoEnzyme{EnzymeCore.ForwardMode{false, EnzymeCore.FFIABI, false, false, false}, Nothing}, OpenMDAOCore.PerturbedDenseSparsityDetector{:direct, ADTypes.AutoForwardDiff{nothing, Nothing}, Float64, Float64}, SparseMatrixColorings.GreedyColoringAlgorithm{:direct, SparseMatrixColorings.NaturalOrder}}, ::ComponentArrays.ComponentVector{Float64, Vector{Float64}, Tuple{ComponentArrays.Axis{(a = 1, b = ViewAxis(2:4, Shaped1DAxis((3,))), c = ViewAxis(5:8, Shaped1DAxis((4,))), d = ViewAxis(9:20, ShapedAxis((4, 3))))}}}; strict::Val{false})
      @ DifferentiationInterface ~/.julia/packages/DifferentiationInterface/zJHX8/src/first_order/jacobian.jl:23
    [6] prepare_jacobian(::OpenMDAOCore.var"#36#37"{typeof(Main.var"##automatic sparsity#190".f_simple!), Tuple{Int64, Int64}}, ::ComponentArrays.ComponentVector{Float64, Vector{Float64}, Tuple{ComponentArrays.Axis{(e = ViewAxis(1:3, Shaped1DAxis((3,))), f = ViewAxis(4:15, ShapedAxis((4, 3))), g = ViewAxis(16:27, ShapedAxis((3, 4))))}}}, ::ADTypes.AutoSparse{ADTypes.AutoEnzyme{EnzymeCore.ForwardMode{false, EnzymeCore.FFIABI, false, false, false}, Nothing}, OpenMDAOCore.PerturbedDenseSparsityDetector{:direct, ADTypes.AutoForwardDiff{nothing, Nothing}, Float64, Float64}, SparseMatrixColorings.GreedyColoringAlgorithm{:direct, SparseMatrixColorings.NaturalOrder}}, ::ComponentArrays.ComponentVector{Float64, Vector{Float64}, Tuple{ComponentArrays.Axis{(a = 1, b = ViewAxis(2:4, Shaped1DAxis((3,))), c = ViewAxis(5:8, Shaped1DAxis((4,))), d = ViewAxis(9:20, ShapedAxis((4, 3))))}}})
      @ DifferentiationInterface ~/.julia/packages/DifferentiationInterface/zJHX8/src/first_order/jacobian.jl:15
    [7] _get_sparse_prep_stuff(ad_backend::ADTypes.AutoSparse{ADTypes.AutoEnzyme{EnzymeCore.ForwardMode{false, EnzymeCore.FFIABI, false, false, false}, Nothing}, OpenMDAOCore.PerturbedDenseSparsityDetector{:direct, ADTypes.AutoForwardDiff{nothing, Nothing}, Float64, Float64}, SparseMatrixColorings.GreedyColoringAlgorithm{:direct, SparseMatrixColorings.NaturalOrder}}, f!::Function, Y_ca::ComponentArrays.ComponentVector{Float64, Vector{Float64}, Tuple{ComponentArrays.Axis{(e = ViewAxis(1:3, Shaped1DAxis((3,))), f = ViewAxis(4:15, ShapedAxis((4, 3))), g = ViewAxis(16:27, ShapedAxis((3, 4))))}}}, X_ca::ComponentArrays.ComponentVector{Float64, Vector{Float64}, Tuple{ComponentArrays.Axis{(a = 1, b = ViewAxis(2:4, Shaped1DAxis((3,))), c = ViewAxis(5:8, Shaped1DAxis((4,))), d = ViewAxis(9:20, ShapedAxis((4, 3))))}}})
      @ OpenMDAOCore ~/.julia/packages/OpenMDAOCore/v5KNT/src/sparse_ad.jl:198
    [8] OpenMDAOCore.SparseADExplicitComp(ad_backend::ADTypes.AutoSparse{ADTypes.AutoEnzyme{EnzymeCore.ForwardMode{false, EnzymeCore.FFIABI, false, false, false}, Nothing}, OpenMDAOCore.PerturbedDenseSparsityDetector{:direct, ADTypes.AutoForwardDiff{nothing, Nothing}, Float64, Float64}, SparseMatrixColorings.GreedyColoringAlgorithm{:direct, SparseMatrixColorings.NaturalOrder}}, f!::typeof(Main.var"##automatic sparsity#190".f_simple!), Y_ca::ComponentArrays.ComponentVector{Float64, Vector{Float64}, Tuple{ComponentArrays.Axis{(e = ViewAxis(1:3, Shaped1DAxis((3,))), f = ViewAxis(4:15, ShapedAxis((4, 3))), g = ViewAxis(16:27, ShapedAxis((3, 4))))}}}, X_ca::ComponentArrays.ComponentVector{Float64, Vector{Float64}, Tuple{ComponentArrays.Axis{(a = 1, b = ViewAxis(2:4, Shaped1DAxis((3,))), c = ViewAxis(5:8, Shaped1DAxis((4,))), d = ViewAxis(9:20, ShapedAxis((4, 3))))}}}; params::Tuple{Int64, Int64}, units_dict::Dict{Symbol, String}, tags_dict::Dict{Symbol, Vector{String}}, shape_by_conn_dict::Dict{Symbol, Bool}, copy_shape_dict::Dict{Symbol, Symbol}, force_skip_prep::Bool, aviary_input_vars::Dict{Symbol, Dict{String, Nothing}}, aviary_output_vars::Dict{Symbol, Dict{String, Nothing}}, aviary_meta_data::Dict{String, Nothing})
      @ OpenMDAOCore ~/.julia/packages/OpenMDAOCore/v5KNT/src/sparse_ad.jl:124
    [9] kwcall(::@NamedTuple{params::Tuple{Int64, Int64}}, ::Type{OpenMDAOCore.SparseADExplicitComp}, ad_backend::ADTypes.AutoSparse{ADTypes.AutoEnzyme{EnzymeCore.ForwardMode{false, EnzymeCore.FFIABI, false, false, false}, Nothing}, OpenMDAOCore.PerturbedDenseSparsityDetector{:direct, ADTypes.AutoForwardDiff{nothing, Nothing}, Float64, Float64}, SparseMatrixColorings.GreedyColoringAlgorithm{:direct, SparseMatrixColorings.NaturalOrder}}, f!::Function, Y_ca::ComponentArrays.ComponentVector{Float64, Vector{Float64}, Tuple{ComponentArrays.Axis{(e = ViewAxis(1:3, Shaped1DAxis((3,))), f = ViewAxis(4:15, ShapedAxis((4, 3))), g = ViewAxis(16:27, ShapedAxis((3, 4))))}}}, X_ca::ComponentArrays.ComponentVector{Float64, Vector{Float64}, Tuple{ComponentArrays.Axis{(a = 1, b = ViewAxis(2:4, Shaped1DAxis((3,))), c = ViewAxis(5:8, Shaped1DAxis((4,))), d = ViewAxis(9:20, ShapedAxis((4, 3))))}}})
      @ OpenMDAOCore ~/.julia/packages/OpenMDAOCore/v5KNT/src/sparse_ad.jl:105
   [10] doit_in_place(; sparse_detect_method::Symbol, ad_type::String)
      @ Main.var"##automatic sparsity#190" ~/.julia/packages/OpenMDAOCore/v5KNT/test/autosparse_automatic.jl:103
   [11] doit_in_place
      @ ~/.julia/packages/OpenMDAOCore/v5KNT/test/autosparse_automatic.jl:69 [inlined]
   [12] top-level scope
      @ ~/.julia/packages/OpenMDAOCore/v5KNT/test/autosparse_automatic.jl:426
   [13] include(mapexpr::Function, mod::Module, _path::String)
      @ Base ./Base.jl:309
   [14] top-level scope
      @ ~/.julia/packages/SafeTestsets/raUNr/src/SafeTestsets.jl:681
   [15] macro expansion
      @ /opt/julia/share/julia/stdlib/v1.13/Test/src/Test.jl:1952 [inlined]
   [16] macro expansion
      @ ~/.julia/packages/OpenMDAOCore/v5KNT/test/runtests.jl:681 [inlined]
   [17] eval(m::Module, e::Any)
      @ Core ./boot.jl:489
   [18] top-level scope
      @ ~/.julia/packages/OpenMDAOCore/v5KNT/test/runtests.jl:677
   [19] macro expansion
      @ /opt/julia/share/julia/stdlib/v1.13/Test/src/Test.jl:1952 [inlined]
   [20] macro expansion
      @ ~/.julia/packages/OpenMDAOCore/v5KNT/test/runtests.jl:680 [inlined]
   [21] macro expansion
      @ ~/.julia/packages/SafeTestsets/raUNr/src/SafeTestsets.jl:28 [inlined]
   [22] include(mapexpr::Function, mod::Module, _path::String)
      @ Base ./Base.jl:309
   [23] top-level scope
      @ none:6
   [24] eval(m::Module, e::Any)
      @ Core ./boot.jl:489
   [25] exec_options(opts::Base.JLOptions)
      @ Base ./client.jl:296
   [26] _start()
      @ Base ./client.jl:563
  in expression starting at /home/pkgeval/.julia/packages/OpenMDAOCore/v5KNT/test/autosparse_automatic.jl:423

automatic sparsity, with Aviary metadata: Error During Test at /home/pkgeval/.julia/packages/SafeTestsets/raUNr/src/SafeTestsets.jl:30
  Got exception outside of a @test
  LoadError: MethodError: no method matching _prepare_pushforward_aux(::Val{false}, ::DifferentiationInterface.PushforwardFast, ::OpenMDAOCore.var"#36#37"{typeof(Main.var"##automatic sparsity, with Aviary metadata#191".f_simple!), Tuple{Int64, Int64}}, ::ComponentArrays.ComponentVector{Float64, Vector{Float64}, Tuple{ComponentArrays.Axis{(f = ViewAxis(1:12, ShapedAxis((4, 3))), e = ViewAxis(13:15, Shaped1DAxis((3,))), g = ViewAxis(16:27, ShapedAxis((3, 4))))}}}, ::ADTypes.AutoEnzyme{EnzymeCore.ForwardMode{false, EnzymeCore.FFIABI, false, false, false}, Nothing}, ::ComponentArrays.ComponentVector{Float64, Vector{Float64}, Tuple{ComponentArrays.Axis{(a = 1, b = ViewAxis(2:4, Shaped1DAxis((3,))), d = ViewAxis(5:16, ShapedAxis((4, 3))), c = ViewAxis(17:20, Shaped1DAxis((4,))))}}}, ::Tuple{ComponentArrays.ComponentVector{Float64, Vector{Float64}, Tuple{ComponentArrays.Axis{(a = 1, b = ViewAxis(2:4, Shaped1DAxis((3,))), d = ViewAxis(5:16, ShapedAxis((4, 3))), c = ViewAxis(17:20, Shaped1DAxis((4,))))}}}})
  The function `_prepare_pushforward_aux` exists, but no method is defined for this combination of argument types.
  The autodiff backend you chose may not be compatible with the operation you want to perform. Please refer to the documentation of DifferentiationInterface.jl and open an issue if necessary.
  Closest candidates are:
    _prepare_pushforward_aux(::Val, !Matched::DifferentiationInterface.PushforwardSlow, ::F, ::Any, ::ADTypes.AbstractADType, ::Any, ::NTuple{N, T} where {N, T}, DifferentiationInterface.Context...) where {F, C}
     @ DifferentiationInterface ~/.julia/packages/DifferentiationInterface/zJHX8/src/first_order/pushforward.jl:293
    _prepare_pushforward_aux(::Val, !Matched::DifferentiationInterface.PushforwardSlow, ::F, !Matched::ADTypes.AbstractADType, ::Any, !Matched::NTuple{N, T} where {N, T}, !Matched::DifferentiationInterface.Context...) where {F, C}
     @ DifferentiationInterface ~/.julia/packages/DifferentiationInterface/zJHX8/src/first_order/pushforward.jl:277
  Stacktrace:
    [1] prepare_pushforward_nokwarg(::Val{false}, ::OpenMDAOCore.var"#36#37"{typeof(Main.var"##automatic sparsity, with Aviary metadata#191".f_simple!), Tuple{Int64, Int64}}, ::ComponentArrays.ComponentVector{Float64, Vector{Float64}, Tuple{ComponentArrays.Axis{(f = ViewAxis(1:12, ShapedAxis((4, 3))), e = ViewAxis(13:15, Shaped1DAxis((3,))), g = ViewAxis(16:27, ShapedAxis((3, 4))))}}}, ::ADTypes.AutoEnzyme{EnzymeCore.ForwardMode{false, EnzymeCore.FFIABI, false, false, false}, Nothing}, ::ComponentArrays.ComponentVector{Float64, Vector{Float64}, Tuple{ComponentArrays.Axis{(a = 1, b = ViewAxis(2:4, Shaped1DAxis((3,))), d = ViewAxis(5:16, ShapedAxis((4, 3))), c = ViewAxis(17:20, Shaped1DAxis((4,))))}}}, ::Tuple{ComponentArrays.ComponentVector{Float64, Vector{Float64}, Tuple{ComponentArrays.Axis{(a = 1, b = ViewAxis(2:4, Shaped1DAxis((3,))), d = ViewAxis(5:16, ShapedAxis((4, 3))), c = ViewAxis(17:20, Shaped1DAxis((4,))))}}}})
      @ DifferentiationInterface ~/.julia/packages/DifferentiationInterface/zJHX8/src/first_order/pushforward.jl:272
    [2] _prepare_sparse_jacobian_aux_aux(::Val{false}, ::DifferentiationInterface.BatchSizeSettings{1, false, true}, ::SparseArrays.SparseMatrixCSC{Bool, Int64}, ::SparseMatrixColorings.ColumnColoringResult{SparseArrays.SparseMatrixCSC{Bool, Int64}, Int64, SparseMatrixColorings.BipartiteGraph{Int64}, Vector{Int64}, Vector{SubArray{Int64, 1, Vector{Int64}, Tuple{UnitRange{Int64}}, true}}, Vector{Int64}, Nothing}, ::ComponentArrays.ComponentVector{Float64, Vector{Float64}, Tuple{ComponentArrays.Axis{(f = ViewAxis(1:12, ShapedAxis((4, 3))), e = ViewAxis(13:15, Shaped1DAxis((3,))), g = ViewAxis(16:27, ShapedAxis((3, 4))))}}}, ::Tuple{OpenMDAOCore.var"#36#37"{typeof(Main.var"##automatic sparsity, with Aviary metadata#191".f_simple!), Tuple{Int64, Int64}}, ComponentArrays.ComponentVector{Float64, Vector{Float64}, Tuple{ComponentArrays.Axis{(f = ViewAxis(1:12, ShapedAxis((4, 3))), e = ViewAxis(13:15, Shaped1DAxis((3,))), g = ViewAxis(16:27, ShapedAxis((3, 4))))}}}}, ::ADTypes.AutoSparse{ADTypes.AutoEnzyme{EnzymeCore.ForwardMode{false, EnzymeCore.FFIABI, false, false, false}, Nothing}, OpenMDAOCore.PerturbedDenseSparsityDetector{:direct, ADTypes.AutoForwardDiff{nothing, Nothing}, Float64, Float64}, SparseMatrixColorings.GreedyColoringAlgorithm{:direct, SparseMatrixColorings.NaturalOrder}}, ::ComponentArrays.ComponentVector{Float64, Vector{Float64}, Tuple{ComponentArrays.Axis{(a = 1, b = ViewAxis(2:4, Shaped1DAxis((3,))), d = ViewAxis(5:16, ShapedAxis((4, 3))), c = ViewAxis(17:20, Shaped1DAxis((4,))))}}})
      @ DifferentiationInterfaceSparseMatrixColoringsExt ~/.julia/packages/DifferentiationInterface/zJHX8/ext/DifferentiationInterfaceSparseMatrixColoringsExt/jacobian.jl:124
    [3] _prepare_sparse_jacobian_aux(::Val{false}, ::DifferentiationInterface.PushforwardFast, ::ComponentArrays.ComponentVector{Float64, Vector{Float64}, Tuple{ComponentArrays.Axis{(f = ViewAxis(1:12, ShapedAxis((4, 3))), e = ViewAxis(13:15, Shaped1DAxis((3,))), g = ViewAxis(16:27, ShapedAxis((3, 4))))}}}, ::Tuple{OpenMDAOCore.var"#36#37"{typeof(Main.var"##automatic sparsity, with Aviary metadata#191".f_simple!), Tuple{Int64, Int64}}, ComponentArrays.ComponentVector{Float64, Vector{Float64}, Tuple{ComponentArrays.Axis{(f = ViewAxis(1:12, ShapedAxis((4, 3))), e = ViewAxis(13:15, Shaped1DAxis((3,))), g = ViewAxis(16:27, ShapedAxis((3, 4))))}}}}, ::ADTypes.AutoSparse{ADTypes.AutoEnzyme{EnzymeCore.ForwardMode{false, EnzymeCore.FFIABI, false, false, false}, Nothing}, OpenMDAOCore.PerturbedDenseSparsityDetector{:direct, ADTypes.AutoForwardDiff{nothing, Nothing}, Float64, Float64}, SparseMatrixColorings.GreedyColoringAlgorithm{:direct, SparseMatrixColorings.NaturalOrder}}, ::ComponentArrays.ComponentVector{Float64, Vector{Float64}, Tuple{ComponentArrays.Axis{(a = 1, b = ViewAxis(2:4, Shaped1DAxis((3,))), d = ViewAxis(5:16, ShapedAxis((4, 3))), c = ViewAxis(17:20, Shaped1DAxis((4,))))}}})
      @ DifferentiationInterfaceSparseMatrixColoringsExt ~/.julia/packages/DifferentiationInterface/zJHX8/ext/DifferentiationInterfaceSparseMatrixColoringsExt/jacobian.jl:90
    [4] prepare_jacobian_nokwarg(::Val{false}, ::OpenMDAOCore.var"#36#37"{typeof(Main.var"##automatic sparsity, with Aviary metadata#191".f_simple!), Tuple{Int64, Int64}}, ::ComponentArrays.ComponentVector{Float64, Vector{Float64}, Tuple{ComponentArrays.Axis{(f = ViewAxis(1:12, ShapedAxis((4, 3))), e = ViewAxis(13:15, Shaped1DAxis((3,))), g = ViewAxis(16:27, ShapedAxis((3, 4))))}}}, ::ADTypes.AutoSparse{ADTypes.AutoEnzyme{EnzymeCore.ForwardMode{false, EnzymeCore.FFIABI, false, false, false}, Nothing}, OpenMDAOCore.PerturbedDenseSparsityDetector{:direct, ADTypes.AutoForwardDiff{nothing, Nothing}, Float64, Float64}, SparseMatrixColorings.GreedyColoringAlgorithm{:direct, SparseMatrixColorings.NaturalOrder}}, ::ComponentArrays.ComponentVector{Float64, Vector{Float64}, Tuple{ComponentArrays.Axis{(a = 1, b = ViewAxis(2:4, Shaped1DAxis((3,))), d = ViewAxis(5:16, ShapedAxis((4, 3))), c = ViewAxis(17:20, Shaped1DAxis((4,))))}}})
      @ DifferentiationInterfaceSparseMatrixColoringsExt ~/.julia/packages/DifferentiationInterface/zJHX8/ext/DifferentiationInterfaceSparseMatrixColoringsExt/jacobian.jl:57
    [5] prepare_jacobian(::OpenMDAOCore.var"#36#37"{typeof(Main.var"##automatic sparsity, with Aviary metadata#191".f_simple!), Tuple{Int64, Int64}}, ::ComponentArrays.ComponentVector{Float64, Vector{Float64}, Tuple{ComponentArrays.Axis{(f = ViewAxis(1:12, ShapedAxis((4, 3))), e = ViewAxis(13:15, Shaped1DAxis((3,))), g = ViewAxis(16:27, ShapedAxis((3, 4))))}}}, ::ADTypes.AutoSparse{ADTypes.AutoEnzyme{EnzymeCore.ForwardMode{false, EnzymeCore.FFIABI, false, false, false}, Nothing}, OpenMDAOCore.PerturbedDenseSparsityDetector{:direct, ADTypes.AutoForwardDiff{nothing, Nothing}, Float64, Float64}, SparseMatrixColorings.GreedyColoringAlgorithm{:direct, SparseMatrixColorings.NaturalOrder}}, ::ComponentArrays.ComponentVector{Float64, Vector{Float64}, Tuple{ComponentArrays.Axis{(a = 1, b = ViewAxis(2:4, Shaped1DAxis((3,))), d = ViewAxis(5:16, ShapedAxis((4, 3))), c = ViewAxis(17:20, Shaped1DAxis((4,))))}}}; strict::Val{false})
      @ DifferentiationInterface ~/.julia/packages/DifferentiationInterface/zJHX8/src/first_order/jacobian.jl:23
    [6] prepare_jacobian(::OpenMDAOCore.var"#36#37"{typeof(Main.var"##automatic sparsity, with Aviary metadata#191".f_simple!), Tuple{Int64, Int64}}, ::ComponentArrays.ComponentVector{Float64, Vector{Float64}, Tuple{ComponentArrays.Axis{(f = ViewAxis(1:12, ShapedAxis((4, 3))), e = ViewAxis(13:15, Shaped1DAxis((3,))), g = ViewAxis(16:27, ShapedAxis((3, 4))))}}}, ::ADTypes.AutoSparse{ADTypes.AutoEnzyme{EnzymeCore.ForwardMode{false, EnzymeCore.FFIABI, false, false, false}, Nothing}, OpenMDAOCore.PerturbedDenseSparsityDetector{:direct, ADTypes.AutoForwardDiff{nothing, Nothing}, Float64, Float64}, SparseMatrixColorings.GreedyColoringAlgorithm{:direct, SparseMatrixColorings.NaturalOrder}}, ::ComponentArrays.ComponentVector{Float64, Vector{Float64}, Tuple{ComponentArrays.Axis{(a = 1, b = ViewAxis(2:4, Shaped1DAxis((3,))), d = ViewAxis(5:16, ShapedAxis((4, 3))), c = ViewAxis(17:20, Shaped1DAxis((4,))))}}})
      @ DifferentiationInterface ~/.julia/packages/DifferentiationInterface/zJHX8/src/first_order/jacobian.jl:15
    [7] _get_sparse_prep_stuff(ad_backend::ADTypes.AutoSparse{ADTypes.AutoEnzyme{EnzymeCore.ForwardMode{false, EnzymeCore.FFIABI, false, false, false}, Nothing}, OpenMDAOCore.PerturbedDenseSparsityDetector{:direct, ADTypes.AutoForwardDiff{nothing, Nothing}, Float64, Float64}, SparseMatrixColorings.GreedyColoringAlgorithm{:direct, SparseMatrixColorings.NaturalOrder}}, f!::Function, Y_ca::ComponentArrays.ComponentVector{Float64, Vector{Float64}, Tuple{ComponentArrays.Axis{(f = ViewAxis(1:12, ShapedAxis((4, 3))), e = ViewAxis(13:15, Shaped1DAxis((3,))), g = ViewAxis(16:27, ShapedAxis((3, 4))))}}}, X_ca::ComponentArrays.ComponentVector{Float64, Vector{Float64}, Tuple{ComponentArrays.Axis{(a = 1, b = ViewAxis(2:4, Shaped1DAxis((3,))), d = ViewAxis(5:16, ShapedAxis((4, 3))), c = ViewAxis(17:20, Shaped1DAxis((4,))))}}})
      @ OpenMDAOCore ~/.julia/packages/OpenMDAOCore/v5KNT/src/sparse_ad.jl:198
    [8] OpenMDAOCore.SparseADExplicitComp(ad_backend::ADTypes.AutoSparse{ADTypes.AutoEnzyme{EnzymeCore.ForwardMode{false, EnzymeCore.FFIABI, false, false, false}, Nothing}, OpenMDAOCore.PerturbedDenseSparsityDetector{:direct, ADTypes.AutoForwardDiff{nothing, Nothing}, Float64, Float64}, SparseMatrixColorings.GreedyColoringAlgorithm{:direct, SparseMatrixColorings.NaturalOrder}}, f!::typeof(Main.var"##automatic sparsity, with Aviary metadata#191".f_simple!), Y_ca::ComponentArrays.ComponentVector{Float64, Vector{Float64}, Tuple{ComponentArrays.FlatAxis}}, X_ca::ComponentArrays.ComponentVector{Float64, Vector{Float64}, Tuple{ComponentArrays.FlatAxis}}; params::Tuple{Int64, Int64}, units_dict::Dict{Symbol, String}, tags_dict::Dict{Symbol, Vector{String}}, shape_by_conn_dict::Dict{Symbol, Bool}, copy_shape_dict::Dict{Symbol, Symbol}, force_skip_prep::Bool, aviary_input_vars::Dict{Symbol, Dict{String}}, aviary_output_vars::Dict{Symbol, Dict{String, String}}, aviary_meta_data::Dict{String, Dict{String, Any}})
      @ OpenMDAOCore ~/.julia/packages/OpenMDAOCore/v5KNT/src/sparse_ad.jl:124
    [9] kwcall(::@NamedTuple{params::Tuple{Int64, Int64}, aviary_input_vars::Dict{Symbol, Dict{String}}, aviary_output_vars::Dict{Symbol, Dict{String, String}}, aviary_meta_data::Dict{String, Dict{String, Any}}}, ::Type{OpenMDAOCore.SparseADExplicitComp}, ad_backend::ADTypes.AutoSparse{ADTypes.AutoEnzyme{EnzymeCore.ForwardMode{false, EnzymeCore.FFIABI, false, false, false}, Nothing}, OpenMDAOCore.PerturbedDenseSparsityDetector{:direct, ADTypes.AutoForwardDiff{nothing, Nothing}, Float64, Float64}, SparseMatrixColorings.GreedyColoringAlgorithm{:direct, SparseMatrixColorings.NaturalOrder}}, f!::Function, Y_ca::ComponentArrays.ComponentVector{Float64, Vector{Float64}, Tuple{ComponentArrays.FlatAxis}}, X_ca::ComponentArrays.ComponentVector{Float64, Vector{Float64}, Tuple{ComponentArrays.FlatAxis}})
      @ OpenMDAOCore ~/.julia/packages/OpenMDAOCore/v5KNT/src/sparse_ad.jl:105
   [10] doit_in_place(; sparse_detect_method::Symbol, ad_type::String)
      @ Main.var"##automatic sparsity, with Aviary metadata#191" ~/.julia/packages/OpenMDAOCore/v5KNT/test/autosparse_automatic_aviary.jl:128
   [11] doit_in_place
      @ ~/.julia/packages/OpenMDAOCore/v5KNT/test/autosparse_automatic_aviary.jl:69 [inlined]
   [12] top-level scope
      @ ~/.julia/packages/OpenMDAOCore/v5KNT/test/autosparse_automatic_aviary.jl:470
   [13] include(mapexpr::Function, mod::Module, _path::String)
      @ Base ./Base.jl:309
   [14] top-level scope
      @ ~/.julia/packages/SafeTestsets/raUNr/src/SafeTestsets.jl:684
   [15] macro expansion
      @ /opt/julia/share/julia/stdlib/v1.13/Test/src/Test.jl:1952 [inlined]
   [16] macro expansion
      @ ~/.julia/packages/OpenMDAOCore/v5KNT/test/runtests.jl:684 [inlined]
   [17] eval(m::Module, e::Any)
      @ Core ./boot.jl:489
   [18] top-level scope
      @ ~/.julia/packages/OpenMDAOCore/v5KNT/test/runtests.jl:677
   [19] macro expansion
      @ /opt/julia/share/julia/stdlib/v1.13/Test/src/Test.jl:1952 [inlined]
   [20] macro expansion
      @ ~/.julia/packages/OpenMDAOCore/v5KNT/test/runtests.jl:683 [inlined]
   [21] macro expansion
      @ ~/.julia/packages/SafeTestsets/raUNr/src/SafeTestsets.jl:28 [inlined]
   [22] include(mapexpr::Function, mod::Module, _path::String)
      @ Base ./Base.jl:309
   [23] top-level scope
      @ none:6
   [24] eval(m::Module, e::Any)
      @ Core ./boot.jl:489
   [25] exec_options(opts::Base.JLOptions)
      @ Base ./client.jl:296
   [26] _start()
      @ Base ./client.jl:563
  in expression starting at /home/pkgeval/.julia/packages/OpenMDAOCore/v5KNT/test/autosparse_automatic_aviary.jl:467
Test Summary:                              | Pass  Error  Total     Time
SparseADExplicitComp                       |  788      3    791  8m31.8s
  manual sparsity                          |           1      1    49.1s
  automatic sparsity                       |  380      1    381  5m11.4s
  automatic sparsity, with Aviary metadata |  408      1    409  2m31.1s
RNG of the outermost testset: Random.Xoshiro(0x78261575bae2bec6, 0x42d06706a143ee12, 0xb9cb7beb540dc96b, 0x51b150afe4cdee31, 0x1d69eaf18494fb6a)
ERROR: LoadError: Some tests did not pass: 788 passed, 0 failed, 3 errored, 0 broken.
in expression starting at /home/pkgeval/.julia/packages/OpenMDAOCore/v5KNT/test/runtests.jl:676

Testing failed after 670.05s

ERROR: LoadError: Package OpenMDAOCore errored during testing
Stacktrace:
  [1] pkgerror(msg::String)
    @ Pkg.Types /opt/julia/share/julia/stdlib/v1.13/Pkg/src/Types.jl:68
  [2] test(ctx::Pkg.Types.Context, pkgs::Vector{PackageSpec}; coverage::Bool, julia_args::Cmd, test_args::Cmd, test_fn::Nothing, force_latest_compatible_version::Bool, allow_earlier_backwards_compatible_versions::Bool, allow_reresolve::Bool)
    @ Pkg.Operations /opt/julia/share/julia/stdlib/v1.13/Pkg/src/Operations.jl:2673
  [3] test
    @ /opt/julia/share/julia/stdlib/v1.13/Pkg/src/Operations.jl:2522 [inlined]
  [4] test(ctx::Pkg.Types.Context, pkgs::Vector{PackageSpec}; coverage::Bool, test_fn::Nothing, julia_args::Cmd, test_args::Cmd, force_latest_compatible_version::Bool, allow_earlier_backwards_compatible_versions::Bool, allow_reresolve::Bool, kwargs::@Kwargs{io::IOContext{IO}})
    @ Pkg.API /opt/julia/share/julia/stdlib/v1.13/Pkg/src/API.jl:538
  [5] kwcall(::@NamedTuple{julia_args::Cmd, io::IOContext{IO}}, ::typeof(Pkg.API.test), ctx::Pkg.Types.Context, pkgs::Vector{PackageSpec})
    @ Pkg.API /opt/julia/share/julia/stdlib/v1.13/Pkg/src/API.jl:515
  [6] test(pkgs::Vector{PackageSpec}; io::IOContext{IO}, kwargs::@Kwargs{julia_args::Cmd})
    @ Pkg.API /opt/julia/share/julia/stdlib/v1.13/Pkg/src/API.jl:168
  [7] kwcall(::@NamedTuple{julia_args::Cmd}, ::typeof(Pkg.API.test), pkgs::Vector{PackageSpec})
    @ Pkg.API /opt/julia/share/julia/stdlib/v1.13/Pkg/src/API.jl:157
  [8] test(pkgs::Vector{String}; kwargs::@Kwargs{julia_args::Cmd})
    @ Pkg.API /opt/julia/share/julia/stdlib/v1.13/Pkg/src/API.jl:156
  [9] test
    @ /opt/julia/share/julia/stdlib/v1.13/Pkg/src/API.jl:156 [inlined]
 [10] kwcall(::@NamedTuple{julia_args::Cmd}, ::typeof(Pkg.API.test), pkg::String)
    @ Pkg.API /opt/julia/share/julia/stdlib/v1.13/Pkg/src/API.jl:155
 [11] top-level scope
    @ /PkgEval.jl/scripts/evaluate.jl:219
 [12] include(mod::Module, _path::String)
    @ Base ./Base.jl:308
 [13] exec_options(opts::Base.JLOptions)
    @ Base ./client.jl:330
 [14] _start()
    @ Base ./client.jl:563
in expression starting at /PkgEval.jl/scripts/evaluate.jl:210

PkgEval failed after 992.69s: package fails to precompile