[isaacsas]

This PR supersedes #570. It contains the JumpProcesses 10 work from that PR, keeps its commit history, merges current master, and adds the remaining v10 changes.

It is set up for a transitional 10.0.0 release.

• StochasticDiffEq, ModelingToolkit, and Catalyst do not support JumpProcesses 10 yet. Every registered version of them caps JumpProcesses below 10, so environments that include them keep JumpProcesses 9.x.
• The README, the docs home page, and HISTORY say so, and recommend waiting for 10.0.1 unless JumpProcesses is used on its own. They also say jump problems coupled to DDEs are not supported in 10.0 at this time.
• The downstream updates follow the release, then 10.0.1 removes the notices and the temporary pins. See "Release plan" below.

Summary of major changes

• RNG ownership: jumps draw random numbers from the integrator's RNG. Pass rng or seed to solve/init; JumpProblem(...; rng) now errors.
• Mass-action rates: solvers and aggregators own the working rate buffers. Parameter-mapped rates are filled from the current parameters at initialization and reset, so remake no longer mutates shared rate coefficients. update_parameters! is removed, and custom parameter mappers have a new contract.
• Jump-state ownership: SSAStepper and the OrdinaryDiffEq paths reuse a JumpProblem's jump state, re-initializing it at every init, and never copy it. A JumpProblem supports one active solve at a time.
  • alias_jump is removed.
  • SSAStepper gains the common alias keyword for u0, p, and tstops.
• SSAStepper integrator evaluation: evaluating the integrator at a time it can't represent now raises an error instead of silently returning the current state. A new SSAStepper(; save_uprev = true) option allows exact evaluation within the current step.
• StochasticDiffEq init: init with an SDE/RODE solver now reaches StochasticDiffEqCore's own JumpProblem initializers, through upstream fixes (OrdinaryDiffEq.jl #4707 and the WIP #4836). JumpProcesses has no StochasticDiffEqCore extension or weak dependency.
  • Until #4836 is released, the tests pin StochasticDiffEqCore, StochasticDiffEqImplicit, and StochasticDiffEqLeaping to a commit of its branch, and CI temporarily skips lts for the Interface groups and ThreadSafety, and the downgrade job.
  • Also fixed: stored JumpProblem callbacks ran twice per step under init on ODE, DAE, and FunctionMap integrators.
• Callbacks on the wrapped problem: callbacks stored on the problem a JumpProblem wraps are now rejected with an informative error. Previously some solvers ran them and others ignored them.
• Documentation: a v10 migration guide, a new tutorial on ensembles and problem reuse, and updated docstrings, FAQ, and HISTORY.

The details follow.

RNG and mass-action rate ownership

Jump callbacks now draw from the integrator's RNG, and each solver or aggregator owns its mass-action working-rate buffer. Supply rng or seed to solve/init; JumpProblem(...; rng) now errors. Parameter-mapped mass-action rates are filled from the current parameters at initialization and reset, so rate coefficients shared by jump definitions are never mutated. The migration guide documents the breaking APIs and the custom mapper contract.

Jump-state ownership

Solvers owned by JumpProcesses (SSAStepper and the OrdinaryDiffEq ODE/DAE pathways) now always reuse the JumpProblem's jump aggregator and callbacks, re-initializing them at every init. They never copy them, on any thread; previously, solves off thread 1 copied this state. Consequences:

• A JumpProblem supports one active solve or integrator at a time.
• Concurrent solves, and integrators alive at the same time, need deepcopy(jprob) or an EnsembleProblem. EnsembleThreads copies the problem once per spawned task, and safetycopy = true copies it for every trajectory.
• Problems created with remake share the original's jump state.

The removed copy shows up directly. For a small SIR model, init on a spawned task allocated 5,952 bytes before this change and 2,912 after, the same as on the main thread.

Keyword changes

• alias_jump is removed. Any supplied value raises a migration error, whether it is passed to solve, init, JumpProblem, or a multi-trajectory EnsembleGPUKernel solve, or stored on the wrapped problem.
  • The plural alias_jumps was never a solver keyword. SciMLBase's keyword validation rejects it on solve/init, and multi-trajectory kernel solves, which bypass that validation, reject it explicitly.
• SSAStepper now supports the common alias keyword for u0, p, and tstops.
  • It accepts a Bool, a SciMLBase.DiscreteAliasSpecifier, or an ODEAliasSpecifier. The last is the specifier OrdinaryDiffEq's FunctionMap already uses for DiscreteProblems, and the one that also controls tstops.
  • The defaults match OrdinaryDiffEq: u0 is copied with recursivecopy, p is reused, and a caller's tstops is never modified. true permits aliasing.
  • tstops given as a number, a tuple, or an AbstractVector other than a Vector of the time type is copied into a Vector at init.
  • alias never controls jump state.
• On coupled ODE/DAE paths, alias is forwarded unchanged.
• StochasticDiffEq SDE/RODE solvers keep their own SDEAliasSpecifier(alias_jumps) policy; this is documented.

Evaluating an SSAIntegrator at a time

Until now, integrator(t) and integrator(out, t) ignored t and returned the current state. That is silently wrong for callbacks that evaluate the integrator at earlier times, such as DiffEqCallbacks' SavingCallback with saveat. The in-place form also errored, because get_tmp_cache was missing.

• The new save_uprev option (SSAStepper(; save_uprev = true), off by default) keeps the state at the start of each step in integrator.uprev. The buffer is updated each step without allocating.

• What each setting allows: with the option on, evaluation is exact anywhere in [integrator.tprev, integrator.t], and get_tmp_cache provides scratch space for in-place callbacks. With the default, evaluation is valid only at integrator.t, and other times raise an informative error.

• Alternatively, pass a callback's evaluation times as tstops. That also gives exact results and avoids the per-step state copy, at the cost of a stop and callback pass at each time. The docs, a new tutorial section, and the FAQ show both approaches.

• Not yet supported: DiffEqCallbacks' integrating callbacks still don't work with SSAStepper, since they need an algorithm order. That is left to an upstream follow-up and documented.

• End-time fix: SSAStepper now saves pending saveat times before its final callback pass at the end time. Previously a callback that changed the state at the end time altered those earlier saved values, and the saved times came out of order.

• Why the option is on the algorithm: SciMLBase's keyword check rejects a new solve keyword. SSAStepper() is unchanged for callers, but its type is now SSAStepper{false}; the isdenseplot method is updated to match.

• Supported state types are now documented:

  • fully supported: Vectors and SVectors of integers or floats, and species × sites matrices for spatial problems. NSM and DirectCRDirect keep the matrix; other aggregators flatten it to a Vector. Bounded VariableRateJumps require Coevolve;
  • still working: scalar states, for models without mass-action jumps. That covers constant-rate jumps with every non-spatial aggregator except RSSA/RSSACR, and bounded variable-rate jumps with Coevolve;
  • other types are unsupported.

  Tests cover each supported type.

StochasticDiffEq initialization and dependencies

Released StochasticDiffEqCore (through 2.2.3) defines an __init method for jump problems that is ambiguous with JumpProcesses' own, so init(jprob, sde_alg) could not reach Core's initializer.

• The fix is upstream:
  • OrdinaryDiffEq.jl #4707 (merged, unreleased) added per-algorithm __init(::JumpProblem, ...) methods.
  • OrdinaryDiffEq.jl #4836 (WIP) narrows Core's remaining union __init to AbstractRODEProblem, and updates StochasticDiffEqCore for v10's RNG and jump-state ownership.
  • With both, init followed by solve! matches solve, and JumpProcesses needs no StochasticDiffEqCore extension or weak dependency.
  • An earlier revision of this PR forwarded stochastic init through a JumpProcessesStochasticDiffEqCoreExt extension; it has been removed.
• Temporary test pins and CI limits:
  • Until #4836 is released, [sources] pins StochasticDiffEqCore, StochasticDiffEqImplicit, and StochasticDiffEqLeaping, as test extras, to an exact commit of its branch.
  • Implicit and Leaping are pinned because the test environment's registered StochasticDiffEq pulls in their registered versions, which do not admit JumpProcesses 10.
  • The pins only affect running the tests. Installing or loading JumpProcesses ignores them, since Pkg honors [sources] only for the active project.
  • Julia 1.10 ignores [sources], and the downgrade action discards URL sources. Registered StochasticDiffEq packages do not admit JumpProcesses 10, so the test environment cannot resolve there. InterfaceI, InterfaceII, and ThreadSafety therefore skip lts, and the downgrade job is disabled, until the pins are removed.
  • The lts benchmarks do not load StochasticDiffEq and still run. QA runs on Julia 1 only.
• Callback fix: callbacks stored in a JumpProblem no longer run twice per step when an ODE, DAE, or FunctionMap integrator is created with init, and are no longer reintroduced under merge_callbacks = false.

Callbacks on the wrapped problem

Callbacks stored on the problem a JumpProblem wraps, for example ODEProblem(f, u0, tspan, p; callback), were run by OrdinaryDiffEq solvers, including FunctionMap, but silently ignored by SSAStepper and StochasticDiffEq solvers.

• New behavior: the JumpProblem constructors, and remake with a new wrapped problem, now raise an informative ArgumentError when the wrapped problem stores a callback.
• Migration: pass callbacks to JumpProblem(...; callback) or to solve/init instead; remake(prob; callback = nothing) removes them from an existing problem.
• Downstream: ModelingToolkitBase and Catalyst attach their events to the outer JumpProblem, so the problems they build are unaffected.
• Documentation: HISTORY, the JumpProblem docstring, the docs, and the migration guide state the rule.

Other changes

• SSAStepper save paths and integrator(t) now use OrdinaryDiffEq's copyat_or_push!/recursivecopy semantics, so nested states are saved as independent snapshots.
• Multi-trajectory EnsembleGPUKernel solves reject alias values other than nothing. They also reject alias_jump, alias_jumps, and alias whether passed to solve or stored on the wrapped problem.
• SSAStepper no longer errors when only the final state is saved (save_end = true with nothing saved earlier); master has the same bug.
• The SciMLBase floor is now 3.34, an existing registered release.
• No SciMLBase source change is required. This is unrelated to the obsolete RNG fork.

Documentation

These rules are documented throughout, with emphasis on the lack of safety in non-serial contexts and with remake:

• HISTORY.md;
• the JumpProblem thread-safety docstring and a new remake(::JumpProblem) docstring;
• the SSAStepper, SortingDirect, and EnsembleGPUKernel docstrings;
• a new API section, the v10 migration guide, and FAQ entries;
• a new tutorial, "Ensembles, remake, and problem reuse", showing patterns that balance performance and safety. It needs no Catalyst or ModelingToolkit dependency.
• the docs now load the specific solver packages they use (OrdinaryDiffEqTsit5, OrdinaryDiffEqRosenbrock, OrdinaryDiffEqFunctionMap, and StochasticDiffEqHighOrder) instead of DifferentialEquations.jl and the OrdinaryDiffEq and StochasticDiffEq umbrella packages. The installation instructions now recommend JumpProcesses plus a solver package.

SortingDirect deliberately retains its learned search order across solves, for repeated-sampling performance. This is documented, along with the conditions for exact replay.

Documentation CI runs again.

• Until ModelingToolkitBase, Catalyst, and StochasticDiffEqCore release JumpProcesses 10 support, docs/Project.toml pins them through [sources] to exact commits of their JumpProcesses 10 branches: WIP: Support JumpProcesses 10 in ModelingToolkitBase jump problems ModelingToolkit.jl#5269, WIP: Support JumpProcesses 10 in tests, benchmarks, and docs Catalyst.jl#1572, and #4836.
• The JumpProblem docstring links the new tutorial's stable URL, which linkcheck ignores until the 10.0 docs are deployed.

History and relation to #570

This branch preserves the feature history from #570. Its changes since #570's head are in this comparison.

• It merges master through 1816ee40 (Type RDirectJumpAggregation.counter_threshold as Int #676) and migrates master's new tests to v10's solve-time RNG ownership.
• It reconciles CPU tau-leaping and kernel RNG behavior with the v10 ownership rules.
• The version is now 10.0.0.

Release plan

1. Merge this PR and register 10.0.0, with CI and docs green on the pinned commits. The lts Interface and ThreadSafety jobs and the downgrade job stay off.
2. Downstream updates. The WIP PRs currently admit JumpProcesses 9.x, 10 so that the pins resolve on either side of this bump. Each one then requires "10", removes its pins, merges, and releases, in this order:
   1. StochasticDiffEq, #4836 (Core, Implicit, and Leaping);
   2. ModelingToolkitBase, WIP: Support JumpProcesses 10 in ModelingToolkitBase jump problems ModelingToolkit.jl#5269;
   3. Catalyst, WIP: Support JumpProcesses 10 in tests, benchmarks, and docs Catalyst.jl#1572.
3. 10.0.1:
   • remove the notices and all test and docs pins;
   • restore lts and the downgrade job;
   • drop the linkcheck_ignore entry once the 10.0 docs are deployed.

Local validation

These are results from local runs.

• At 10.0.0, with the exact-commit pins, on Julia 1.12.7:
  • the test environment resolves with registered StochasticDiffEq 7.2.0 and the pinned Core, Implicit, and Leaping, and stochastic dispatch passes 287/287;
  • the docs environment resolves with the pinned Catalyst, ModelingToolkitBase, and StochasticDiffEqCore;
  • a full docs build runs every doctest and example, including the Catalyst tutorial. Its link check failed only on curl timeouts to existing external links, all of which respond normally on recheck.
• The previous head (9.33.1, extension removed, StochasticDiffEqCore pinned to #4836's branch), on Julia 1.12.7:
  • stochastic dispatch 287/287, RNG keyword 36/36, callbacks 162/162, variable-rate 76/76, and strict QA 20/20 pass;
  • #4836's JumpProblem tests pass against this branch, 141/141;
  • a full docs build against the Catalyst, ModelingToolkitBase, and StochasticDiffEqCore branches runs every doctest and example, including the Catalyst tutorial, and renders the site. The link check fails only on the not-yet-deployed tutorial URL, now ignored, and on transient external timeouts or rate limits.

The full matrix below ran earlier, with the previous forwarding extension. All of its dependency graphs were resolved freshly from the registry, with no source overrides, on the tree just before the final master merge. That merge (#676) changes one field type and adds one test; the affected tests, strict QA, and the style checks pass after it.

• Latest registered dependencies: InterfaceI 1,861/1,861 and InterfaceII 3,344/3,344 on both Julia 1.12.7 and 1.10.12. Four-thread ThreadSafety passes 333/333 and strict native Pkg.test QA passes 20/20, both on Julia 1.12.7. The versions were SciMLBase 3.57.0, DiffEqBase 7.21.3, OrdinaryDiffEqCore 4.18.1, StochasticDiffEq 7.2.0, and StochasticDiffEqCore 2.2.3.
• The downgrade action's minimum graph (Julia 1.10, four threads; SciMLBase 3.39.0, DiffEqBase 7.5.0, OrdinaryDiffEq 7.0.0, StochasticDiffEq 7.0.0, StochasticDiffEqCore 2.2.1): the All group passes, 5,540/5,540.
• A package-only graph at JumpProcesses' floors (SciMLBase 3.34.0, DiffEqBase 7.0.0, OrdinaryDiffEqCore 4.0.0): the init/solve callback checks and the wrapped-callback rejection pass.
• Precompilation and formatting: strict precompilation and every extension load order pass on both Julia versions. JuliaFormatter, typos, and whitespace checks are clean.
• Documentation: the new tutorial section's examples and the FAQ and migration snippets run, and a Documenter build of the changed pages succeeds.
• Benchmarks: SSA allocations are identical to before. save_uprev = true is within noise for a three-species model and about 1.9 times slower on a 2,500-site spatial model, which is why it is off by default.

Not run locally: actual CUDA (the kernel tests run on the CPU KernelAbstractions backend) and Julia prerelease. The unseeded adaptive ThreadSafety warning remains an explicitly deferred investigation.

🤖 Generated with Claude Code 2.1.293 (model: claude-opus-5-5[1m])