Drop Runic reformatting and check from this PR

JumpProcesses ran the centralized JuliaFormatter format-check, not Runic.
Switching it to the centralized Runic check reformatted the entire repo
(~85 files), which is too large to bundle with the CI migration. Restore
the original FormatCheck.yml (JuliaFormatter) and revert the reformatting;
Runic adoption can be a separate, focused PR.

Kept: Documentation/Downgrade/SpellCheck central callers, dependabot
cleanup, _typos.toml, and the 2 real typo fixes the spell check surfaced.

Co-Authored-By: Chris Rackauckas <accounts@chrisrackauckas.com>
Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: ChrisRackauckas

.github/workflows/FormatCheck.yml

@@ -0,0 +1,13 @@
+name: "Format Check"
+
+on:
+  push:
+    branches:
+      - 'master'
+    tags: '*'
+  pull_request:
+
+jobs:
+  format-check:
+    name: "Format Check"
+    uses: "SciML/.github/.github/workflows/format-check.yml@v1"

.github/workflows/Runic.yml

@@ -10,7 +10,7 @@ benchmark_out = ExtendedJumpArray(zeros(500000), zeros(500000))
 benchmark_in = ExtendedJumpArray(rand(rng, 500000), rand(rng, 500000))
 
 function test_single_dot(out, array)
-    return @inbounds @. out = array + 1.23 * array
+    @inbounds @. out = array + 1.23 * array
 end
 
 println("Base-case normal broadcasting")

benchmarks/extended_jump_array.jl

@@ -11,33 +11,23 @@ cp(joinpath(docpath, "Project.toml"), joinpath(assetpath, "Project.toml"), force
 
 include("pages.jl")
 
-mathengine = MathJax3(
-    Dict(
-        :loader => Dict("load" => ["[tex]/require", "[tex]/mathtools"]), :tex => Dict(
-            "inlineMath" => [["\$", "\$"], ["\\(", "\\)"]],
-            "packages" => [
-                "base",
-                "ams",
-                "autoload",
-                "mathtools",
-                "require",
-            ]
-        )
-    )
-)
+mathengine = MathJax3(Dict(:loader => Dict("load" => ["[tex]/require", "[tex]/mathtools"]), :tex => Dict("inlineMath" => [["\$", "\$"], ["\\(", "\\)"]],
+        "packages" => [
+            "base",
+            "ams",
+            "autoload",
+            "mathtools",
+            "require"
+        ])))
 
-makedocs(
-    sitename = "JumpProcesses.jl", authors = "Chris Rackauckas", modules = [JumpProcesses],
+makedocs(sitename = "JumpProcesses.jl", authors = "Chris Rackauckas", modules = [JumpProcesses],
     clean = true, doctest = false, linkcheck = true, warnonly = [:missing_docs],
-    format = Documenter.HTML(;
-        assets = ["assets/favicon.ico"],
+    format = Documenter.HTML(; assets = ["assets/favicon.ico"],
         canonical = "https://docs.sciml.ai/JumpProcesses/",
         prettyurls = (get(ENV, "CI", nothing) == "true"),
         mathengine,
         edit_link = "master",
-        repolink = "https://github.com/SciML/JumpProcesses.jl"
-    ),
-    pages = pages
-)
+        repolink = "https://github.com/SciML/JumpProcesses.jl"),
+    pages = pages)
 
 deploydocs(repo = "github.com/SciML/JumpProcesses.jl.git"; push_preview = true)

docs/make.jl

@@ -1,19 +1,14 @@
 # Put in a separate page so it can be used by SciMLDocs.jl
 
-pages = [
-    "index.md",
-    "Tutorials" => Any[
-        "tutorials/simple_poisson_process.md",
+pages = ["index.md",
+    "Tutorials" => Any["tutorials/simple_poisson_process.md",
         "tutorials/discrete_stochastic_example.md",
         "tutorials/point_process_simulation.md",
         "tutorials/jump_diffusion.md",
-        "tutorials/spatial.md",
-    ],
+        "tutorials/spatial.md"],
     "Applications" => Any["applications/advanced_point_process.md"],
-    "Type Documentation" => Any[
-        "Jumps, JumpProblem, and Aggregators" => "jump_types.md",
-        "Jump solvers" => "jump_solve.md",
-    ],
+    "Type Documentation" => Any["Jumps, JumpProblem, and Aggregators" => "jump_types.md",
+        "Jump solvers" => "jump_solve.md"],
     "FAQ" => "faq.md",
-    "API" => "api.md",
+    "API" => "api.md"
 ]

docs/pages.jl

@@ -5,24 +5,20 @@ using KernelAbstractions, Adapt
 using StaticArrays
 using PoissonRandom, Random
 
-function SciMLBase.__solve(
-        ensembleprob::SciMLBase.AbstractEnsembleProblem,
+function SciMLBase.__solve(ensembleprob::SciMLBase.AbstractEnsembleProblem,
         alg::SimpleTauLeaping,
         ensemblealg::EnsembleGPUKernel;
         trajectories,
         seed = nothing,
         dt = error("dt is required for SimpleTauLeaping."),
-        kwargs...
-    )
+        kwargs...)
     if trajectories == 1
-        return SciMLBase.__solve(
-            ensembleprob, alg, EnsembleSerial(); trajectories = 1,
-            seed, dt, kwargs...
-        )
+        return SciMLBase.__solve(ensembleprob, alg, EnsembleSerial(); trajectories = 1,
+            seed, dt, kwargs...)
     end
 
     ensemblealg.backend === nothing ? backend = CPU() :
-        backend = ensemblealg.backend
+    backend = ensemblealg.backend
 
     jump_prob = ensembleprob.prob
 
@@ -35,42 +31,36 @@ function SciMLBase.__solve(
 
     # Run vectorized solve
     ts,
-        us = vectorized_solve(
-        probs, jump_prob, SimpleTauLeaping(); backend, trajectories, seed, dt
-    )
+    us = vectorized_solve(
+        probs, jump_prob, SimpleTauLeaping(); backend, trajectories, seed, dt)
 
     # Convert to CPU for inspection
     _ts = Array(ts)
     _us = Array(us)
 
-    time = @elapsed sol = [
-        begin
-                ts = @view _ts[:, i]
-                us = @view _us[:, :, i]
-                sol_idx = findlast(x -> x != probs[i].prob.tspan[1], ts)
-                if sol_idx === nothing
-                    @error "No solution found" tspan = probs[i].tspan[1] ts
-                    error("Batch solve failed")
-            end
-                @views ensembleprob.output_func(
-                    SciMLBase.build_solution(
-                        probs[i].prob,
-                        alg,
-                        ts[1:sol_idx],
-                        [us[j, :] for j in 1:sol_idx],
-                        k = nothing,
-                        stats = nothing,
-                        calculate_error = false,
-                        retcode = sol_idx !=
-                        length(ts) ?
-                        ReturnCode.Terminated :
-                        ReturnCode.Success
-                    ),
-                    i
-                )[1]
-            end
-            for i in eachindex(probs)
-    ]
+    time = @elapsed sol = [begin
+                               ts = @view _ts[:, i]
+                               us = @view _us[:, :, i]
+                               sol_idx = findlast(x -> x != probs[i].prob.tspan[1], ts)
+                               if sol_idx === nothing
+                                   @error "No solution found" tspan=probs[i].tspan[1] ts
+                                   error("Batch solve failed")
+                               end
+                               @views ensembleprob.output_func(
+                                   SciMLBase.build_solution(probs[i].prob,
+                                       alg,
+                                       ts[1:sol_idx],
+                                       [us[j, :] for j in 1:sol_idx],
+                                       k = nothing,
+                                       stats = nothing,
+                                       calculate_error = false,
+                                       retcode = sol_idx !=
+                                                 length(ts) ?
+                                                 ReturnCode.Terminated :
+                                                 ReturnCode.Success),
+                                   i)[1]
+                           end
+                           for i in eachindex(probs)]
     return SciMLBase.EnsembleSolution(sol, time, true)
 end
 
@@ -92,8 +82,7 @@ end
 @kernel function simple_tau_leaping_kernel(
         @Const(probs_data), _us, _ts, dt, @Const(rj_data),
         current_u_buf, rate_cache_buf, counts_buf, local_dc_buf,
-        seed::UInt64
-    )
+        seed::UInt64)
     i = @index(Global, Linear)
 
     # Get thread-local buffers
@@ -125,7 +114,7 @@ end
 
     # Get input/output arrays
     ts_view = @inbounds view(_ts, :, i)
-    us_view = @inbounds view(_us, :, :, i)
+    us_view = @inbounds view(_us,:,:,i)
 
     # Initialize first time step and state
     @inbounds ts_view[1] = tspan[1]
@@ -135,7 +124,7 @@ end
 
     # Main loop
     for j in 2:n
-        tprev = tspan[1] + (j - 2) * dt
+        tprev = tspan[1] + (j-2) * dt
 
         # Compute rates and scale by dt
         rate(rate_cache, current_u, p, tprev)
@@ -154,24 +143,20 @@ end
         @inbounds for k in 1:state_dim
             us_view[j, k] = current_u[k]
         end
-        @inbounds ts_view[j] = tspan[1] + (j - 1) * dt
+        @inbounds ts_view[j] = tspan[1] + (j-1) * dt
     end
 end
 
 # Vectorized solve function
-function vectorized_solve(
-        probs, prob::JumpProblem, alg::SimpleTauLeaping;
-        backend, trajectories, seed, dt, kwargs...
-    )
+function vectorized_solve(probs, prob::JumpProblem, alg::SimpleTauLeaping;
+        backend, trajectories, seed, dt, kwargs...)
     # Extract common jump data
     rj = prob.regular_jump
     rj_data = JumpData(rj.rate, rj.c, rj.numjumps)
 
     # Extract trajectory-specific data without static typing
-    probs_data = [
-        TrajectoryData(SA{eltype(p.prob.u0)}[p.prob.u0...], p.prob.p, p.prob.tspan)
-            for p in probs
-    ]
+    probs_data = [TrajectoryData(SA{eltype(p.prob.u0)}[p.prob.u0...], p.prob.p, p.prob.tspan)
+                  for p in probs]
 
     # Adapt to GPU
     probs_data_gpu = adapt(backend, probs_data)
@@ -212,15 +197,13 @@ function vectorized_solve(
     KernelAbstractions.synchronize(backend)
 
     # Seed for Poisson sampling
-    seed = seed === nothing ? UInt64(12345) : UInt64(seed)
+    seed = seed === nothing ? UInt64(12345) : UInt64(seed);
 
     # Launch main kernel
     kernel = simple_tau_leaping_kernel(backend)
-    main_event = kernel(
-        probs_data_gpu, us, ts, dt, rj_data_gpu,
+    main_event = kernel(probs_data_gpu, us, ts, dt, rj_data_gpu,
         current_u_buf, rate_cache_buf, counts_buf, local_dc_buf, seed;
-        ndrange = n_trajectories
-    )
+        ndrange = n_trajectories)
     KernelAbstractions.synchronize(backend)
 
     return ts, us

ext/JumpProcessesKernelAbstractionsExt.jl

@@ -16,14 +16,11 @@ import OrdinaryDiffEqCore: OrdinaryDiffEqAlgorithm, DAEAlgorithm,
 # the exact algorithm union from OrdinaryDiffEqCore.
 function DiffEqBase.__init(
         _jump_prob::DiffEqBase.AbstractJumpProblem{P},
-        alg::Union{
-            OrdinaryDiffEqAlgorithm, DAEAlgorithm,
-            StochasticDiffEqAlgorithm, StochasticDiffEqRODEAlgorithm,
-        };
-        merge_callbacks = true, kwargs...
-    ) where {P}
+        alg::Union{OrdinaryDiffEqAlgorithm, DAEAlgorithm,
+            StochasticDiffEqAlgorithm, StochasticDiffEqRODEAlgorithm};
+        merge_callbacks = true, kwargs...) where {P}
     kwargs = DiffEqBase.merge_problem_kwargs(_jump_prob; merge_callbacks, kwargs...)
-    return JumpProcesses.__jump_init(_jump_prob, alg; kwargs...)
+    JumpProcesses.__jump_init(_jump_prob, alg; kwargs...)
 end
 
 end

ext/JumpProcessesOrdinaryDiffEqCoreExt.jl

@@ -36,18 +36,18 @@ import SymbolicIndexingInterface as SII
 
 # Import additional types and functions from DiffEqBase and SciMLBase
 using DiffEqBase: DiffEqBase, CallbackSet, ContinuousCallback, DAEFunction,
-    DDEFunction, DiscreteProblem, ODEFunction, ODEProblem,
-    ODESolution, ReturnCode, SDEFunction, SDEProblem, add_tstop!,
-    deleteat!, isinplace, remake, savevalues!, step!,
-    u_modified!
+                  DDEFunction, DiscreteProblem, ODEFunction, ODEProblem,
+                  ODESolution, ReturnCode, SDEFunction, SDEProblem, add_tstop!,
+                  deleteat!, isinplace, remake, savevalues!, step!,
+                  u_modified!
 using SciMLBase: SciMLBase, DEIntegrator
 
 abstract type AbstractJump end
 abstract type AbstractMassActionJump <: AbstractJump end
 abstract type AbstractAggregatorAlgorithm end
 abstract type AbstractJumpAggregator end
 abstract type AbstractSSAIntegrator{Alg, IIP, U, T} <:
-DEIntegrator{Alg, IIP, U, T} end
+              DEIntegrator{Alg, IIP, U, T} end
 
 const DEFAULT_RNG = Random.default_rng()
 
@@ -129,7 +129,7 @@ export init, solve, solve!
 include("SSA_stepper.jl")
 export SSAStepper
 
-# leaping:
+# leaping: 
 include("simple_regular_solve.jl")
 export SimpleTauLeaping, SimpleExplicitTauLeaping, EnsembleGPUKernel