@mcmcjs/julia 0.19.0 → 0.21.0

package/dist/index.cjs

@@ -36,6 +36,7 @@ __export(index_exports, {
   planSetup: () => planSetup,
   predictData: () => predictData,
   removeVersion: () => removeVersion,
+  resolveJulia: () => resolveJulia,
   resolveVersion: () => resolveVersion,
   runDoctor: () => runDoctor,
   runFit: () => runFit,
@@ -242,7 +243,7 @@ end
 
 serve(ARGS[1])
 `,
-  "fitlib.jl": '# MCMC.js fit library, shared by the one-shot driver (driver.jl) and the\n# persistent worker (worker.jl). handle_request runs one fit or predict request\n# (Turing or JuliaBUGS) and writes the draws as the @mcmcjs/core samples\n# artifact (a flat JSON wire). This is the only place that touches the backend\n# chain type (FlexiChains), so a chain-type change is contained here.\nusing JSON\nusing Logging\nimport Distributed\nusing Random\nusing StableRNGs\nusing Turing\nusing Turing: VarName\nusing SHA\nusing Pkg\n# Imported (not `using`) so they do not pull `@model` etc. into Main and clash\n# with Turing\'s exports, which would break Turing model files on include.\nimport JuliaBUGS\nimport AdvancedHMC\n# Loading SliceSampling activates JuliaBUGS\'s extension for its derivative-free samplers.\nimport SliceSampling\nimport ForwardDiff\n# Loading Mooncake activates AbstractPPL\'s native extension for AutoMooncake.\nimport Mooncake\n# Loading ReverseDiff activates the DynamicPPL extension for AutoReverseDiff.\nimport ReverseDiff\nimport FlexiChains\nimport DimensionalData\n\n# Workers include this file to mirror the master\'s definitions (ModelData, the\n# helpers a deserialized model may reference) when sampling MCMCDistributed.\nconst FITLIB_FILE = @__FILE__\n\n# AbstractMCMC reports sampling progress through ProgressLogging (reachable via\n# Turing\'s dependency, no extra package in the managed env).\nconst ProgressLogging = Turing.AbstractMCMC.ProgressLogging\n\n# Where progress JSON lines go: the driver leaves this on stderr; the worker\n# points it at the client socket for the duration of a request.\nconst PROGRESS_IO = Ref{IO}(stderr)\n\n# Translates ProgressLogging records into one JSON line per update\n# ({"mcmcjs":"progress",...}). The TypeScript side filters these out of the\n# failure protocol\'s stderr buffer. Info-and-above records pass through to a\n# plain console logger; Debug records (AdvancedHMC step-size search) are dropped.\nstruct JSONProgressLogger <: Logging.AbstractLogger\n    fallback::Logging.AbstractLogger\n    last::Dict{Int,Float64}\nend\nJSONProgressLogger() =\n    JSONProgressLogger(Logging.ConsoleLogger(stderr, Logging.Info), Dict{Int,Float64}())\n\nLogging.min_enabled_level(::JSONProgressLogger) = Logging.BelowMinLevel\nLogging.shouldlog(::JSONProgressLogger, args...) = true\nLogging.catch_exceptions(::JSONProgressLogger) = true\n\nfunction emit_progress(logger::JSONProgressLogger, name, fraction, done)\n    m = match(r"Chain (\\d+) of (\\d+)", String(name))\n    chain = m === nothing ? 1 : parse(Int, m.captures[1])\n    of = m === nothing ? 1 : parse(Int, m.captures[2])\n    f = done ? 1.0 : fraction === nothing ? 0.0 : Float64(fraction)\n    # AbstractMCMC already steps by 1%; the dedupe guards chattier emitters.\n    if done || f - get(logger.last, chain, -1.0) >= 0.01\n        logger.last[chain] = f\n        println(\n            PROGRESS_IO[],\n            JSON.json(\n                Dict(\n                    "mcmcjs" => "progress",\n                    "chain" => chain,\n                    "of" => of,\n                    "fraction" => round(f; digits = 4),\n                    "done" => done,\n                ),\n            ),\n        )\n        flush(PROGRESS_IO[])\n    end\nend\n\nfunction Logging.handle_message(\n    logger::JSONProgressLogger, level, message, _module, group, id, file, line; kwargs...\n)\n    progress = message isa ProgressLogging.ProgressString ? message.progress :\n        message isa ProgressLogging.Progress ? message : nothing\n    if progress !== nothing\n        emit_progress(logger, progress.name, progress.fraction, progress.done)\n        return\n    end\n    if haskey(kwargs, :progress) && (kwargs[:progress] isa Real || kwargs[:progress] == "done")\n        value = kwargs[:progress]\n        emit_progress(logger, string(message), value == "done" ? nothing : value, value == "done")\n        return\n    end\n    level >= Logging.Info || return\n    Logging.handle_message(logger.fallback, level, message, _module, group, id, file, line; kwargs...)\nend\n\n# A Turing model file may declare the AD backend it needs by exporting, e.g.,\n# `const MCMC_DEFAULTS = (; adtype = "mooncake")`. A spec or flag adtype wins;\n# the model default fills in only when the request leaves adtype unset.\nfunction apply_model_defaults(sampler, mod)\n    haskey(sampler, "adtype") && return sampler\n    # Only the gradient samplers take an AD backend.\n    get(sampler, "algorithm", "NUTS") in ("NUTS", "HMC", "HMCDA", "Gibbs", "External") ||\n        return sampler\n    Base.invokelatest(isdefined, mod, :MCMC_DEFAULTS) || return sampler\n    defaults = Base.invokelatest(getfield, mod, :MCMC_DEFAULTS)\n    hasproperty(defaults, :adtype) || return sampler\n    merged = copy(sampler)\n    merged["adtype"] = String(defaults.adtype)\n    return merged\nend\n\nfunction build_adtype(name)\n    name == "forwarddiff" && return Turing.ADTypes.AutoForwardDiff()\n    name == "reversediff" && return Turing.ADTypes.AutoReverseDiff()\n    name == "mooncake" && return Turing.ADTypes.AutoMooncake(; config = nothing)\n    error("unsupported adtype: $name")\nend\n\nfunction build_sampler(sampler, modelmod = nothing)\n    algorithm = get(sampler, "algorithm", "NUTS")\n    # Prior draws are iid: no warmup, no adaptation. The JuliaBUGS path samples\n    # ancestrally (sample_bugs_prior) instead of going through a sampler object.\n    algorithm == "Prior" && return Turing.Prior(), 0\n    warmup = Int(get(sampler, "warmup", 1000))\n    adapt_delta = Float64(get(sampler, "adapt_delta", 0.8))\n    algorithm == "MH" && return Turing.MH(), warmup\n    algorithm == "ESS" && return Turing.ESS(), warmup\n    algorithm == "SMC" && return Turing.SMC(), warmup\n    algorithm == "PG" && return Turing.PG(Int(sampler["particles"])), warmup\n    adkw = haskey(sampler, "adtype") ? (; adtype = build_adtype(sampler["adtype"])) : (;)\n    algorithm == "NUTS" && return Turing.NUTS(warmup, adapt_delta; adkw...), warmup\n    algorithm == "HMC" &&\n        return Turing.HMC(Float64(sampler["step_size"]), Int(sampler["leapfrog_steps"]); adkw...),\n        warmup\n    algorithm == "HMCDA" &&\n        return Turing.HMCDA(warmup, adapt_delta, Float64(sampler["lambda"]); adkw...), warmup\n    algorithm == "Gibbs" && return build_gibbs(sampler, adkw, warmup), warmup\n    if algorithm == "External"\n        modelmod === nothing && error("the External algorithm applies to Turing models only")\n        Base.invokelatest(isdefined, modelmod, :MCMC_SAMPLER) ||\n            error("algorithm External needs the model file to define MCMC_SAMPLER")\n        ext = Base.invokelatest(getfield, modelmod, :MCMC_SAMPLER)\n        return Turing.externalsampler(ext; adkw...), warmup\n    end\n    error("unsupported sampler algorithm: $algorithm")\nend\n\n# One Gibbs component: the block\'s variables get the block\'s sampler. A single\n# variable keys by symbol, several by tuple, matching Turing\'s constructor.\nfunction block_sampler(block, adkw, warmup)\n    algorithm = get(block, "algorithm", "NUTS")\n    adapt_delta = Float64(get(block, "adapt_delta", 0.8))\n    algorithm == "MH" && return Turing.MH()\n    algorithm == "ESS" && return Turing.ESS()\n    algorithm == "PG" && return Turing.PG(Int(block["particles"]))\n    algorithm == "NUTS" && return Turing.NUTS(warmup, adapt_delta; adkw...)\n    algorithm == "HMC" &&\n        return Turing.HMC(Float64(block["step_size"]), Int(block["leapfrog_steps"]); adkw...)\n    algorithm == "HMCDA" &&\n        return Turing.HMCDA(warmup, adapt_delta, Float64(block["lambda"]); adkw...)\n    error("unsupported Gibbs block algorithm: $algorithm")\nend\n\nfunction build_gibbs(sampler, adkw, warmup)\n    pairs = map(sampler["blocks"]) do block\n        vars = Symbol.(block["variables"])\n        key = length(vars) == 1 ? vars[1] : Tuple(vars)\n        key => block_sampler(block, adkw, warmup)\n    end\n    return Turing.Gibbs(pairs...)\nend\n\n# Extra keyword arguments for AbstractMCMC.sample, from the request\'s sampler\n# table: thinning, burn-in for the non-adaptive samplers (NUTS and HMCDA discard\n# their own adaptation), and named starting values replicated across chains.\nfunction sampling_kwargs(sampler, warmup, chains)\n    kw = (;)\n    thin = Int(get(sampler, "thin", 1))\n    thin > 1 && (kw = merge(kw, (; thinning = thin)))\n    algorithm = get(sampler, "algorithm", "NUTS")\n    if algorithm in ("MH", "HMC", "ESS", "PG", "Gibbs", "External") && warmup > 0\n        kw = merge(kw, (; discard_initial = warmup))\n    end\n    # AdvancedHMC-style external samplers adapt only when told how many steps to\n    # use; without n_adapts a chain can freeze at its initial point.\n    if algorithm == "External" && warmup > 0\n        kw = merge(kw, (; n_adapts = warmup))\n    end\n    # NUTS/HMCDA blocks inside Gibbs adapt only through the sample-level nadapts\n    # keyword (the constructor\'s count is ignored there); without it the block\n    # never tunes its step size and can freeze.\n    if algorithm == "Gibbs" && warmup > 0\n        blocks = get(sampler, "blocks", Any[])\n        if any(get(b, "algorithm", "NUTS") in ("NUTS", "HMCDA") for b in blocks)\n            kw = merge(kw, (; nadapts = warmup))\n        end\n    end\n    if haskey(sampler, "initial_params")\n        nt = (; (Symbol(k) => narrow(v) for (k, v) in sampler["initial_params"])...)\n        strategy = Turing.DynamicPPL.InitFromParams(nt)\n        kw = merge(kw, (; initial_params = fill(strategy, chains)))\n    end\n    return kw\nend\n\n# Binds the data so a model can read a variable as a property (`data.y`) or by\n# index (`data["y"]` / `data[:y]`), with `haskey`/`keys` supported, so models\n# written in either idiom run unchanged. The underlying NamedTuple is reached\n# via getfield to avoid colliding with a data variable also named `nt`.\nstruct ModelData\n    nt::NamedTuple\nend\nBase.getproperty(d::ModelData, k::Symbol) = getproperty(getfield(d, :nt), k)\nBase.getindex(d::ModelData, k::Symbol) = getproperty(getfield(d, :nt), k)\nBase.getindex(d::ModelData, k::AbstractString) = getproperty(getfield(d, :nt), Symbol(k))\nBase.haskey(d::ModelData, k::Symbol) = haskey(getfield(d, :nt), k)\nBase.haskey(d::ModelData, k::AbstractString) = haskey(getfield(d, :nt), Symbol(k))\nBase.keys(d::ModelData) = keys(getfield(d, :nt))\nBase.propertynames(d::ModelData) = propertynames(getfield(d, :nt))\n\n# JuliaBUGS requires dense arrays with a concrete numeric eltype, but JSON parses\n# them as Vector{Any} (and nested arrays as vectors of vectors). narrow promotes a\n# numeric array to a concrete eltype and stacks equal-sized nested arrays into a\n# dense array; an empty array becomes Float64[].\nfunction narrow(v::AbstractVector)\n    isempty(v) && return Float64[]\n    elems = [narrow(x) for x in v]\n    if all(e -> e isa AbstractArray, elems) && allequal(size.(elems))\n        return stack(elems; dims = 1)\n    end\n    return eltype(elems) <: Real && !isconcretetype(eltype(elems)) ? float.(elems) : elems\nend\nnarrow(x) = x\n\n# JSON null arrives as `nothing`; map it to `missing`, which both PPLs read as an\n# unobserved entry: a sampling statement rather than an observation.\nto_missing(x) = x === nothing ? missing : (x isa AbstractVector ? map(to_missing, x) : x)\nto_namedtuple(data) = (; (Symbol(k) => to_missing(v) for (k, v) in data)...)\n\n# JuliaBUGS backs an array\'s unobserved entries with the eltype of its observed\n# ones, so an integer censoring time would leave a continuous latent an Int slot\n# to live in. Float64 holds a count just as exactly, so it holds either.\nfunction allow_missing(v::AbstractArray)\n    any(ismissing, v) || return v\n    return convert(AbstractArray{Union{Missing,Float64}}, v)\nend\nallow_missing(x) = x\n\nbugs_namedtuple(data) =\n    (; (Symbol(k) => allow_missing(narrow(to_missing(v))) for (k, v) in data)...)\n\n# Rebuild a posterior VNChain (latents only) from our samples wire so it can feed\n# Turing\'s predict. Scalar leaves are regrouped into their array-valued VarName\n# (theta[1..8] -> @varname(theta) holding an 8-vector), so predict matches the\n# model\'s parameters exactly instead of relying on leaf reconstruction. Target\n# outcome columns are excluded.\nfunction wire_to_vnchain(wire, targets)\n    sz = wire["size"]\n    nIter, total, nChains = Int(sz[1]), Int(sz[2]), Int(sz[3])\n    flat = wire["value_flat"]\n    index = Dict(n => i for (i, n) in enumerate(wire["parameters"]))\n    is_target(n) = any(t -> n == t || startswith(n, t * "["), targets)\n    keep = [n for n in wire["name_map"]["parameters"] if !is_target(n)]\n    cell(name, i, c) = begin\n        p = index[name]\n        v = flat[i + (p - 1) * nIter + (c - 1) * nIter * total]\n        v === nothing ? NaN : Float64(v)\n    end\n    base_of(n) = (b = findfirst(\'[\', n); b === nothing ? n : n[1:prevind(n, b)])\n    idx_of(n) = begin\n        b = findfirst(\'[\', n)\n        b === nothing && return Int[]\n        inner = n[nextind(n, b):prevind(n, findlast(\']\', n))]\n        parse.(Int, split(inner, \',\'))\n    end\n    groups = Dict{String,Vector{String}}()\n    for n in keep\n        push!(get!(groups, base_of(n), String[]), n)\n    end\n    dict = Dict{FlexiChains.ParameterOrExtra{<:VarName},Array}()\n    for (base, names) in groups\n        vn = eval(:(Turing.@varname($(Meta.parse(base)))))\n        if length(names) == 1 && isempty(idx_of(names[1]))\n            m = Matrix{Float64}(undef, nIter, nChains)\n            for c in 1:nChains, i in 1:nIter\n                m[i, c] = cell(names[1], i, c)\n            end\n            dict[FlexiChains.Parameter(vn)] = m\n        else\n            idxs = [idx_of(n) for n in names]\n            D = length(idxs[1])\n            dims = ntuple(d -> maximum(ix[d] for ix in idxs), D)\n            m = Matrix{Array{Float64,D}}(undef, nIter, nChains)\n            for c in 1:nChains, i in 1:nIter\n                a = Array{Float64,D}(undef, dims...)\n                for (n, ix) in zip(names, idxs)\n                    a[ix...] = cell(n, i, c)\n                end\n                m[i, c] = a\n            end\n            dict[FlexiChains.Parameter(vn)] = m\n        end\n    end\n    return FlexiChains.FlexiChain{VarName}(nIter, nChains, dict)\nend\n\n# Expand one sampler transition to canonical scalar leaves (theta -> theta[1], ...),\n# the same names the final samples file uses, so streamed batches reconstruct it.\n# Sampler statistics (acceptance rate, tree depth, ...) ride along under the same\n# names the samples file records as internals, so consumers get per-draw\n# diagnostics without a second channel; Bool stats become 0/1.\nfunction flatten_draw(transition)\n    out = Pair{String,Float64}[]\n    for (vn, val) in pairs(transition.params)\n        for (leaf, leafval) in Turing.DynamicPPL.varname_and_value_leaves(vn, val)\n            push!(out, string(leaf) => Float64(leafval))\n        end\n    end\n    if hasproperty(transition, :stats)\n        for (name, value) in pairs(transition.stats)\n            value isa Real && push!(out, string(name) => Float64(value))\n        end\n    end\n    return out\nend\n\n# A per-draw callback that emits {"mcmcjs":"draws",...} batches on PROGRESS_IO as\n# sampling proceeds. AbstractMCMC passes the 1-based chain index as `chain_number`;\n# each batch carries a per-chain monotonic seq, and a chain\'s batches concatenate\n# (by leaf name) to the final samples file. Assumes the callback is not invoked\n# concurrently across chains (true for the MCMCSerial path build_and_sample uses).\nfunction draw_streamer(draws_per_chain::Int, batch_size::Int)\n    chain = Ref(-1)\n    seq = Ref(0)\n    names = String[]\n    buffer = Dict{String,Vector{Float64}}()\n    filled = Ref(0)\n    function emit(iteration)\n        filled[] == 0 && return\n        cols = Dict{String,Vector{Float64}}(n => copy(buffer[n]) for n in names)\n        println(\n            PROGRESS_IO[],\n            JSON.json(\n                Dict(\n                    "mcmcjs" => "draws",\n                    "chain" => chain[],\n                    "seq" => seq[],\n                    "iteration" => iteration,\n                    "draws" => cols,\n                ),\n            ),\n        )\n        flush(PROGRESS_IO[])\n        seq[] += 1\n        for n in names\n            empty!(buffer[n])\n        end\n        filled[] = 0\n    end\n    return function (_rng, _model, _sampler, transition, _state, iteration; chain_number = 1, _kwargs...)\n        c = Int(chain_number) - 1\n        if c != chain[]\n            chain[] = c\n            seq[] = 0\n        end\n        leaves = flatten_draw(transition)\n        if isempty(names)\n            for (n, _) in leaves\n                push!(names, n)\n                buffer[n] = Float64[]\n            end\n        end\n        for (n, v) in leaves\n            push!(get!(buffer, n, Float64[]), v)\n        end\n        filled[] += 1\n        if filled[] >= batch_size || iteration >= draws_per_chain\n            emit(iteration)\n        end\n    end\nend\n\n# Turing observes a variable only when its name is a model argument. A dict-reading\n# model (`y = data["y"]; y[i] ~ dist`) would otherwise SAMPLE its outcome instead of\n# observing it, so condition the built model on the data columns to turn each such\n# `~` into an observation. Columns that are already model arguments are skipped: they\n# are observed by construction, and conditioning one that is also an argument errors.\n# Do not probe the model to find latent columns (e.g. via VarInfo): evaluating a\n# dict-reading model assigns prior draws into the array the data is read from,\n# corrupting it before we condition. Predictor columns carry no `~`, so conditioning\n# on them is a harmless no-op.\nfunction condition_on_data(model, data)\n    nt = data isa ModelData ? getfield(data, :nt) : data\n    nt isa NamedTuple || return model\n    argnames = keys(model.args)\n    pairs = [k => getproperty(nt, k) for k in keys(nt) if Base.isidentifier(string(k)) && !(k in argnames)]\n    isempty(pairs) && return model\n    return Turing.DynamicPPL.condition(model, (; pairs...))\nend\n\n# Build the model and sample in one call so both run in the latest world age:\n# the model methods are defined by `include` at runtime, so a plain call from\n# this (older) world would fail with "method too new". invokelatest fixes that.\n# Returns Turing\'s default chain type, a FlexiChain. With a callback, draws stream.\nfunction build_and_sample(\n    entry, data, sampler, draws, chains, rng; callback = nothing, extra = (;), parallel = "serial"\n)\n    model = condition_on_data(entry(data), data)\n    kw = callback === nothing ? extra : merge(extra, (; callback))\n    ensemble = parallel == "threads" ? MCMCThreads() :\n        parallel == "distributed" ? MCMCDistributed() : MCMCSerial()\n    return Logging.with_logger(JSONProgressLogger()) do\n        sample(rng, model, sampler, ensemble, draws, chains; progress = true, kw...)\n    end\nend\n\n# Distributed chains need the model\'s definitions on every process: workers get\n# this file (ModelData and friends), then all processes include the model file\n# into Main so the serialized model\'s references resolve identically everywhere.\nfunction setup_distributed(chains, model_file)\n    missing_workers = chains - Distributed.nworkers()\n    if Distributed.nprocs() == 1 || missing_workers > 0\n        Distributed.addprocs(\n            Distributed.nprocs() == 1 ? chains : missing_workers;\n            exeflags = ["--project=$(Base.active_project())", "--startup-file=no"],\n        )\n        Distributed.remotecall_eval(\n            Main, Distributed.workers(), :(Base.include(Main, $FITLIB_FILE))\n        )\n    end\n    Distributed.remotecall_eval(Main, Distributed.procs(), :(Base.include(Main, $model_file)))\nend\n\n# The internals section: one scalar column per sampler statistic, as\n# (name, (iter, chain) -> value) pairs. An array-valued statistic (a slice\n# sampler reports a proposal count per coordinate) splits into name[i] columns\n# the way array parameters do, so nothing the sampler reported is dropped.\nfunction extra_columns(chn)\n    cols = Tuple{String,Function}[]\n    for e in FlexiChains.extras(chn)\n        m = chn[e]\n        name = string(Symbol(e))\n        if eltype(m) <: Union{Missing,Real}\n            push!(cols, (name, (i, c) -> m[i, c]))\n        elseif eltype(m) <: AbstractArray && eltype(eltype(m)) <: Union{Missing,Real}\n            for idx in eachindex(m[1, 1])\n                push!(cols, ("$name[$idx]", (i, c) -> m[i, c][idx]))\n            end\n        end\n    end\n    return cols\nend\n\n# FlexiChains-native wire writer. DimArray(chn) splits array-valued parameters\n# into scalar leaves (theta -> theta[1], theta[2]) in the (iter, chain, param)\n# orientation; the sampler\'s statistics become the internals section. `keep`\n# decides by leaf name which columns are written; nothing keeps them all.\nfunction vnchain_to_wire(chn; keep = nothing)\n    da = DimensionalData.DimArray(chn)\n    names = string.(collect(DimensionalData.lookup(da, :param)))\n    arr = parent(da)\n    nIter, nChains, _ = size(arr)\n    kept = keep === nothing ? eachindex(names) : findall(keep, names)\n    pnames = names[kept]\n    nParams = length(kept)\n\n    extras = extra_columns(chn)\n    enames = first.(extras)\n    total = nParams + length(extras)\n\n    flat = Vector{Union{Float64,Nothing}}(undef, nIter * total * nChains)\n    # JSON has no Inf/NaN; a non-finite draw (e.g. 1/sqrt(tau) under a diffuse\n    # prior) becomes null, which the samples parser reads back as NaN.\n    cell(v) = v === missing || !isfinite(v) ? nothing : Float64(v)\n    for c in 1:nChains, (p, src) in enumerate(kept), i in 1:nIter\n        flat[i + (p - 1) * nIter + (c - 1) * nIter * total] = cell(arr[i, c, src])\n    end\n    for (k, (_, draw)) in enumerate(extras)\n        p = nParams + k\n        for c in 1:nChains, i in 1:nIter\n            flat[i + (p - 1) * nIter + (c - 1) * nIter * total] = cell(draw(i, c))\n        end\n    end\n\n    return Dict(\n        "size" => [nIter, total, nChains],\n        "value_flat" => flat,\n        "parameters" => vcat(pnames, enames),\n        "name_map" => Dict("parameters" => pnames, "internals" => enames),\n    )\nend\n\n# A BUGSModel carries its own `base_model` field (the unconditioned model, or\n# nothing), so unwrapping has to test the wrapper\'s type, not for the field.\nbase_bugs(model) = model isa JuliaBUGS.BUGSModelWithGradient ? model.base_model : model\n\n# `[model].monitor` names the deterministic quantities worth storing; the model\'s\n# parameters are always stored. Unset keeps every column the chain carries. The\n# graph\'s parameter list is read rather than `model_parameters`, which in the\n# marginalized mode leaves out the discrete latents the chain still carries.\nfunction bugs_column_filter(request, model)\n    monitor = get(request["model"], "monitor", nothing)\n    monitor === nothing && return nothing\n    keep = Set{String}(String.(monitor))\n    for vn in base_bugs(model).graph_evaluation_data.model_parameters\n        push!(keep, String(JuliaBUGS.AbstractPPL.getsym(vn)))\n    end\n    return name -> first(split(name, \'[\'; limit = 2)) in keep\nend\n\n# JuliaBUGS samplers that propose in the evaluation environment, so they move the\n# discrete latents themselves rather than needing them summed out.\nconst ENV_BASED_BUGS_SAMPLERS = ("MH", "Gibbs")\n\n# Switches a model to the evaluation mode the spec names. The generated and\n# marginalized modes read parameters in unconstrained space, so both need a\n# transformed model first. invokelatest is needed because JuliaBUGS `Core.eval`s\n# the model\'s node functions while compiling, putting them in a newer world than\n# this frame; the generated mode `Core.eval`s a log-density function here too.\nfunction set_bugs_mode(model, name)\n    name == "graph" &&\n        return Base.invokelatest(JuliaBUGS.set_evaluation_mode, model, JuliaBUGS.UseGraph())\n    mode = name == "generated" ? JuliaBUGS.UseGeneratedLogDensityFunction() :\n        name == "marginalized" ? JuliaBUGS.UseAutoMarginalization() :\n        error("unsupported evaluation mode: $name")\n    return Base.invokelatest(\n        JuliaBUGS.set_evaluation_mode, JuliaBUGS.settrans(model, true), mode,\n    )\nend\n\n# Named starting values, in constrained space, as the spec records them. A name\n# the model does not have at all is an error, since `initialize!` would ignore it\n# silently. A name that is a variable but not a parameter, an observed node or a\n# deterministic one, is left out, as BUGS does with such initial values; the\n# published inits of the classic examples carry them.\nfunction initialize_bugs_model(model, sampler)\n    haskey(sampler, "initial_params") || return model\n    gd = base_bugs(model).graph_evaluation_data\n    name(vn) = String(JuliaBUGS.AbstractPPL.getsym(vn))\n    parameters = Set(name.(gd.model_parameters))\n    known = Set(name.(gd.sorted_nodes))\n    for k in keys(sampler["initial_params"])\n        k in known || error("initial_params names $k, which is not a variable of this model")\n    end\n    inits = Dict(k => v for (k, v) in sampler["initial_params"] if k in parameters)\n    isempty(inits) && return model\n    return Base.invokelatest(JuliaBUGS.initialize!, model, bugs_namedtuple(inits))\nend\n\n# With no evaluation mode chosen, a gradient sampler gets the discrete finite\n# latents summed out of the log density, since it cannot move them itself. A model\n# that is discrete throughout has nothing left for it to sample.\nfunction marginalize_if_discrete(base)\n    base.evaluation_mode isa JuliaBUGS.UseGraph || return base\n    marginalized = set_bugs_mode(base, "marginalized")\n    cache = marginalized.marginalization_cache\n    (cache === nothing || cache.n_discrete_finite == 0) && return base\n    Base.invokelatest(JuliaBUGS.LogDensityProblems.dimension, marginalized) == 0 && error(\n        "every parameter of this model is discrete, which a gradient sampler cannot move; use the MH sampler",\n    )\n    return marginalized\nend\n\n# An environment-based sampler starts from the model\'s evaluation environment and\n# accepts on `logp_proposed - logp_current`, which is NaN when both are -Inf: from\n# an impossible starting point the chain can never move. Say so, with the fix,\n# rather than return draws that never left the start.\nfunction check_bugs_start(model, sampler)\n    logp = try\n        last(Base.invokelatest(JuliaBUGS.AbstractPPL.evaluate!!, model))\n    catch\n        -Inf\n    end\n    isfinite(logp) && return model\n    detail = haskey(sampler, "initial_params") ?\n        "the given initial_params have zero probability under the model" :\n        "the model\'s default starting values have zero probability under the data; " *\n        "set [sampler.initial_params] to a state the data allows"\n    return error("$(get(sampler, "algorithm", "MH")) cannot start: $detail")\nend\n\n# Applies the request\'s options to a compiled model: the spec\'s evaluation mode\n# over whatever the model file chose, the initial values, and the AD backend. The\n# gradient wrapper holds a prepared gradient over one base model, so it is rebuilt\n# whenever the base changes.\nfunction prepare_bugs_model(model, sampler, mode_name)\n    base = base_bugs(model)\n    if get(sampler, "algorithm", "NUTS") in ENV_BASED_BUGS_SAMPLERS\n        # Marginalizing would sum out the very latents these samplers propose, so\n        # they always run against the plain model under graph evaluation.\n        base = initialize_bugs_model(set_bugs_mode(base, "graph"), sampler)\n        return check_bugs_start(base, sampler)\n    end\n    base = mode_name === nothing ? marginalize_if_discrete(base) : set_bugs_mode(base, mode_name)\n    base = initialize_bugs_model(base, sampler)\n    # A derivative-free sampler wants the plain model: preparing a gradient it\n    # never calls costs a compile, which for Mooncake runs into minutes.\n    get(sampler, "algorithm", "NUTS") == "Slice" && return base\n    adtype = haskey(sampler, "adtype") ? build_adtype(sampler["adtype"]) :\n        model isa JuliaBUGS.BUGSModelWithGradient ? model.adtype :\n        Turing.ADTypes.AutoForwardDiff()\n    return Base.invokelatest(JuliaBUGS.BUGSModelWithGradient, base, adtype)\nend\n\n# AdvancedHMC starts from a fresh draw unless handed a starting vector, so an\n# initialized model\'s values reach a gradient sampler through this. The\n# environment-based samplers start from the model\'s own environment, which\n# `initialize!` has already set.\nfunction bugs_initial_params(model, sampler)\n    haskey(sampler, "initial_params") || return nothing\n    get(sampler, "algorithm", "NUTS") in ENV_BASED_BUGS_SAMPLERS && return nothing\n    return Base.invokelatest(JuliaBUGS.getparams, base_bugs(model))\nend\n\n# The AdvancedHMC sampler for a NUTS/HMC/HMCDA configuration, whole or per Gibbs\n# block; nothing for any other algorithm. Adaptation runs off `sample`\'s n_adapts,\n# so no constructor here takes a step count.\nfunction bugs_hmc_sampler(conf)\n    algorithm = get(conf, "algorithm", "NUTS")\n    adapt_delta = Float64(get(conf, "adapt_delta", 0.8))\n    algorithm == "NUTS" && return AdvancedHMC.NUTS(adapt_delta)\n    algorithm == "HMC" &&\n        return AdvancedHMC.HMC(Float64(conf["step_size"]), Int(conf["leapfrog_steps"]))\n    algorithm == "HMCDA" && return AdvancedHMC.HMCDA(adapt_delta, Float64(conf["lambda"]))\n    return nothing\nend\n\n# SliceSampling\'s univariate samplers move one coordinate at a time, so a\n# multi-parameter target needs a multivariate strategy around them. RandPermGibbs\n# cycles the coordinates in a random order, and reduces to the plain univariate\n# update when a Gibbs block leaves only one.\nfunction bugs_slice_sampler(conf)\n    width = Float64(conf["slice_width"])\n    return SliceSampling.RandPermGibbs(SliceSampling.SliceSteppingOut(width))\nend\n\n# The support of each variable, as `Gibbs` itself classifies it. The stored value\n# does not say: JuliaBUGS keeps a latent count in a Float64 array, so a count\n# reads as continuous and would draw a Gaussian proposal it cannot represent.\nfunction bugs_node_types(model)\n    gd = model.graph_evaluation_data\n    return Dict(zip(gd.sorted_nodes, Base.invokelatest(JuliaBUGS.Model._compute_node_types, model)))\nend\n\n# A Gaussian step never lands on an integer, so a block of counts gets a lattice\n# walk. `Gibbs` draws a finite discrete block exactly instead, whatever it is\n# given here.\nfunction bugs_mh_kernel(model, vns, node_types)\n    expanded = JuliaBUGS.expand_variables(vns, model.graph_evaluation_data.model_parameters)\n    all(vn -> get(node_types, vn, :continuous) === :discrete_infinite, expanded) ||\n        return JuliaBUGS.AdvancedMH.RobustAdaptiveMetropolis()\n    return JuliaBUGS.AdvancedMH.RWMH([DiscreteUniform(-1, 1) for _ in expanded])\nend\n\n# One block per parameter, each with the kernel its own support calls for. The\n# convenience `Gibbs(model, sampler)` gives every block the same one.\nfunction bugs_single_site_mh(model)\n    node_types = bugs_node_types(model)\n    pairs = [\n        vn => bugs_mh_kernel(model, [vn], node_types) for\n        vn in JuliaBUGS.model_parameters(model)\n    ]\n    return JuliaBUGS.Gibbs(model, JuliaBUGS.OrderedDict(pairs))\nend\n\nbugs_varname(name) = eval(:(Turing.@varname($(Meta.parse(name)))))\n\n# One spec block becomes one entry of JuliaBUGS\'s sampler map, keyed by the\n# block\'s variables together; gradient blocks must carry their AD backend as a\n# tuple. JuliaBUGS checks that the map covers every parameter exactly once.\nfunction build_bugs_gibbs(sampler, model)\n    adtype = build_adtype(get(sampler, "adtype", "forwarddiff"))\n    node_types = bugs_node_types(model)\n    pairs = map(sampler["blocks"]) do block\n        vars = [bugs_varname(v) for v in block["variables"]]\n        key = length(vars) == 1 ? vars[1] : vars\n        algorithm = get(block, "algorithm", "NUTS")\n        component = algorithm == "MH" ? bugs_mh_kernel(model, vars, node_types) :\n            algorithm == "Slice" ? bugs_slice_sampler(block) :\n            (bugs_hmc_sampler(block), adtype)\n        key => component\n    end\n    return JuliaBUGS.Gibbs(model, JuliaBUGS.OrderedDict(pairs))\nend\n\n# Unlike the Turing path this needs the model: JuliaBUGS\'s Gibbs validates its\n# sampler map against the model\'s parameters as it is constructed.\nfunction build_bugs_sampler(sampler, model)\n    hmc = bugs_hmc_sampler(sampler)\n    hmc === nothing || return hmc\n    algorithm = get(sampler, "algorithm", "NUTS")\n    algorithm == "Slice" && return bugs_slice_sampler(sampler)\n    # Single-site Metropolis over every parameter: the WinBUGS-shaped sampler, and\n    # the route to discrete latents that marginalization declines.\n    algorithm == "MH" && return bugs_single_site_mh(model)\n    algorithm == "Gibbs" && return build_bugs_gibbs(sampler, model)\n    return error("the juliabugs backend does not support the $algorithm sampler")\nend\n\n# JuliaBUGS compiles the model at runtime, so building and sampling must run in\n# separate latest-world frames; merging them reintroduces a world-age error.\n# Returns a FlexiChain like the Turing path; gen_chains recovers generated\n# quantities (unobserved nodes with no observed descendants) after sampling.\n# With a callback, draws stream (see bugs_draw_streamer).\nfunction sample_bugs(\n    model, sampler, warmup, draws, chains, rng;\n    callback = nothing, thin = 1, threads = false, initial_params = nothing,\n)\n    kw = callback === nothing ? (;) : (; callback)\n    thin > 1 && (kw = merge(kw, (; thinning = thin)))\n    # Ensemble sampling wants one starting point per chain; every chain starts from\n    # the values the spec named, and diverges from there through its own stream.\n    initial_params === nothing ||\n        (kw = merge(kw, (; initial_params = fill(initial_params, chains))))\n    ensemble = threads ? JuliaBUGS.AbstractMCMC.MCMCThreads() : JuliaBUGS.AbstractMCMC.MCMCSerial()\n    return Logging.with_logger(JSONProgressLogger()) do\n        JuliaBUGS.AbstractMCMC.sample(\n            rng, model, sampler, ensemble, draws, chains;\n            chain_type = FlexiChains.VNChain, n_adapts = warmup, discard_initial = warmup,\n            progress = true, kw...,\n        )\n    end\nend\n\n# JuliaBUGS prior sampling: each draw is one ancestral pass (evaluate!! with an\n# rng samples every unobserved stochastic node from its prior and recomputes the\n# deterministic ones; observed data stays fixed). The collected variables are the\n# model parameters plus generated quantities, the same columns a posterior fit\n# produces through gen_chains.\nfunction sample_bugs_prior(model, draws, chains, rng)\n    model = base_bugs(model)\n    APPL = JuliaBUGS.AbstractPPL\n    vars = vcat(JuliaBUGS.model_parameters(model), JuliaBUGS.generated_quantities(model))\n    isempty(vars) && error("the model has no parameters or generated quantities to sample")\n    grab(env, vn) = (v = APPL.getvalue(env, vn); v isa AbstractArray ? copy(v) : v)\n    columns = Dict(vn => Vector{Any}(undef, draws * chains) for vn in vars)\n    for c in 1:chains, i in 1:draws\n        env, _ = APPL.evaluate!!(rng, model)\n        for vn in vars\n            columns[vn][i + (c - 1) * draws] = grab(env, vn)\n        end\n    end\n    dict = Dict{FlexiChains.ParameterOrExtra{<:VarName},Array}(\n        FlexiChains.Parameter(vn) =>\n            [columns[vn][i + (c - 1) * draws] for i in 1:draws, c in 1:chains] for vn in vars\n    )\n    return FlexiChains.FlexiChain{VarName}(draws, chains, dict)\nend\n\n# The JuliaBUGS counterpart to draw_streamer. A JuliaBUGS transition carries an\n# unconstrained parameter vector (or, for the environment-based samplers, an\n# evaluation environment), so (unlike the Turing path) draws cannot be read off it\n# directly: the generated quantities and any marginalized discrete latents are\n# reconstructed only when the draws are laid out. Per batch we therefore build a\n# small FlexiChain through the same bundle_transitions + vnchain_to_wire path the\n# final file uses, so the streamed leaf names match the file exactly, on a copy of\n# the model so reconstruction never perturbs the sampler\'s state. AbstractMCMC\n# passes the 1-based chain index as chain_number; each chain\'s batches carry a\n# per-chain monotonic seq.\nfunction bugs_draw_streamer(\n    model, sampler, draws_per_chain::Int, batch_size::Int; keep = nothing,\n)\n    recon = deepcopy(model)\n    side_rng = StableRNG(0)\n    chain = Ref(-1)\n    seq = Ref(0)\n    transitions = Any[]\n    function emit(iteration)\n        isempty(transitions) && return\n        chn = JuliaBUGS.bundle_transitions(\n            FlexiChains.VNChain, recon, transitions, sampler; rng = side_rng,\n        )\n        wire = vnchain_to_wire(chn; keep)\n        nIter, total, _ = wire["size"]\n        flat = wire["value_flat"]\n        params = wire["parameters"]\n        cols = Dict(params[p] => [flat[i + (p - 1) * nIter] for i in 1:nIter] for p in 1:total)\n        println(\n            PROGRESS_IO[],\n            JSON.json(\n                Dict(\n                    "mcmcjs" => "draws",\n                    "chain" => chain[],\n                    "seq" => seq[],\n                    "iteration" => iteration,\n                    "draws" => cols,\n                ),\n            ),\n        )\n        flush(PROGRESS_IO[])\n        seq[] += 1\n        empty!(transitions)\n    end\n    return function (_rng, _model, _sampler, transition, _state, iteration; chain_number = 1, _kwargs...)\n        c = Int(chain_number) - 1\n        if c != chain[]\n            chain[] = c\n            seq[] = 0\n            empty!(transitions)\n        end\n        push!(transitions, deepcopy(transition))\n        if length(transitions) >= batch_size || iteration >= draws_per_chain\n            emit(iteration)\n        end\n    end\nend\n\n# JuliaBUGS pointwise log-likelihood: restore each posterior draw into the\n# evaluation environment, recompute the deterministic nodes in topological\n# order, and record logpdf per observed node. Every unobserved stochastic node\n# must be covered by the posterior columns, or log p(y | theta) would not be a\n# function of the draw.\nfunction loglik_bugs(model, posterior)\n    model = base_bugs(model)\n    APPL = JuliaBUGS.AbstractPPL\n    gd = model.graph_evaluation_data\n\n    sz = posterior["size"]\n    nIter, nCols, nChains = Int(sz[1]), Int(sz[2]), Int(sz[3])\n    flat = posterior["value_flat"]\n    col = Dict(n => i for (i, n) in enumerate(posterior["parameters"]))\n    posterior_names = Set(posterior["name_map"]["parameters"])\n    cell(i, p, c) = begin\n        v = flat[i + (p - 1) * nIter + (c - 1) * nIter * nCols]\n        v === nothing ? NaN : Float64(v)\n    end\n\n    restore = Tuple{APPL.VarName,Int}[]\n    for vn in JuliaBUGS.model_parameters(model)\n        leaves = collect(APPL.varname_leaves(vn, APPL.getvalue(model.evaluation_env, vn)))\n        found = count(l -> string(l) in posterior_names, leaves)\n        found == length(leaves) ||\n            error("the posterior samples do not cover $(vn); were they produced by fitting this spec?")\n        append!(restore, [(l, col[string(l)]) for l in leaves])\n    end\n    observed = [\n        (vn, i) for (i, vn) in enumerate(gd.sorted_nodes) if\n        gd.is_stochastic_vals[i] && gd.is_observed_vals[i]\n    ]\n    isempty(observed) && error("the model has no observed variables to compute a log-likelihood for")\n\n    pnames = string.(first.(observed))\n    n = length(pnames)\n    flat_out = Vector{Union{Float64,Nothing}}(undef, nIter * n * nChains)\n    for c in 1:nChains, i in 1:nIter\n        env = model.evaluation_env\n        for (leaf, p) in restore\n            env = JuliaBUGS.BangBang.setindex!!(env, cell(i, p, c), leaf)\n        end\n        for (k, node) in enumerate(gd.sorted_nodes)\n            if !gd.is_stochastic_vals[k]\n                env = JuliaBUGS.BangBang.setindex!!(\n                    env, gd.node_function_vals[k](env, gd.loop_vars_vals[k]), node,\n                )\n            end\n        end\n        for (k, (vn, idx)) in enumerate(observed)\n            dist = gd.node_function_vals[idx](env, gd.loop_vars_vals[idx])\n            v = logpdf(dist, APPL.getvalue(env, vn))\n            flat_out[i + (k - 1) * nIter + (c - 1) * nIter * n] = isfinite(v) ? Float64(v) : nothing\n        end\n    end\n    return Dict(\n        "size" => [nIter, n, nChains],\n        "value_flat" => flat_out,\n        "parameters" => pnames,\n        "name_map" => Dict("parameters" => pnames, "internals" => String[]),\n    )\nend\n\n# JuliaBUGS posterior prediction: condition the (target-blanked) model on the\n# posterior parameter columns, then evaluate!! ancestral-samples the remaining\n# latents once per posterior draw. No sampler or gradient runs.\nfunction predict_bugs(model, posterior, targets, rng)\n    model = base_bugs(model)\n    APPL = JuliaBUGS.AbstractPPL\n    target_syms = Set(Symbol.(targets))\n    is_target(vn) = APPL.getsym(vn) in target_syms\n\n    sz = posterior["size"]\n    nIter, nCols, nChains = Int(sz[1]), Int(sz[2]), Int(sz[3])\n    flat = posterior["value_flat"]\n    col = Dict(n => i for (i, n) in enumerate(posterior["parameters"]))\n    posterior_names = Set(posterior["name_map"]["parameters"])\n    cell(i, p, c) = begin\n        v = flat[i + (p - 1) * nIter + (c - 1) * nIter * nCols]\n        v === nothing ? NaN : Float64(v)\n    end\n\n    # Nodes fully covered by posterior columns are conditioned; anything\n    # uncovered stays latent and is forward-sampled, like Turing.predict.\n    gd = model.graph_evaluation_data\n    conditioned = APPL.VarName[]\n    restore = Tuple{APPL.VarName,Int}[]\n    for (i, vn) in enumerate(gd.sorted_nodes)\n        (gd.is_stochastic_vals[i] && !gd.is_observed_vals[i] && !is_target(vn)) || continue\n        leaves = collect(APPL.varname_leaves(vn, APPL.getvalue(model.evaluation_env, vn)))\n        found = count(l -> string(l) in posterior_names, leaves)\n        if found == length(leaves)\n            push!(conditioned, vn)\n            append!(restore, [(l, col[string(l)]) for l in leaves])\n        elseif found > 0\n            error("the posterior samples cover $(vn) only partially; refit before predicting")\n        end\n    end\n    isempty(conditioned) &&\n        error("the posterior samples share no parameters with the model; were they produced by fitting this spec?")\n    cond = APPL.condition(model, conditioned)\n\n    any(is_target, cond.graph_evaluation_data.sorted_nodes) ||\n        error("no variables predicted; check that [predict].targets name model variables")\n\n    out_leaves = APPL.VarName[]\n    arr = Array{Float64,3}(undef, 0, 0, 0)\n    for c in 1:nChains, i in 1:nIter\n        env = cond.evaluation_env\n        for (leaf, p) in restore\n            env = JuliaBUGS.BangBang.setindex!!(env, cell(i, p, c), leaf)\n        end\n        cond = JuliaBUGS.BangBang.setproperty!!(cond, :evaluation_env, env)\n        drawn, _ = APPL.evaluate!!(rng, cond)\n        if isempty(out_leaves)\n            out_leaves = [\n                l for vn in cond.graph_evaluation_data.sorted_nodes if is_target(vn)\n                for l in APPL.varname_leaves(vn, APPL.getvalue(drawn, vn))\n            ]\n            arr = Array{Float64,3}(undef, nIter, length(out_leaves), nChains)\n        end\n        for (k, leaf) in enumerate(out_leaves)\n            arr[i, k, c] = Float64(APPL.getvalue(drawn, leaf))\n        end\n    end\n\n    pnames = string.(out_leaves)\n    n = length(pnames)\n    flat_out = Vector{Union{Float64,Nothing}}(undef, nIter * n * nChains)\n    for c in 1:nChains, p in 1:n, i in 1:nIter\n        v = arr[i, p, c]\n        flat_out[i + (p - 1) * nIter + (c - 1) * nIter * n] = isfinite(v) ? v : nothing\n    end\n    return Dict(\n        "size" => [nIter, n, nChains],\n        "value_flat" => flat_out,\n        "parameters" => pnames,\n        "name_map" => Dict("parameters" => pnames, "internals" => String[]),\n    )\nend\n\nfunction provenance()\n    packages = Dict{String,String}()\n    for (_, info) in Pkg.dependencies()\n        if info.name in\n           ("Turing", "FlexiChains", "DynamicPPL", "AbstractMCMC", "JuliaBUGS", "AdvancedHMC", "SliceSampling", "ForwardDiff", "Mooncake", "ADTypes") &&\n           info.version !== nothing\n            packages[info.name] = string(info.version)\n        end\n    end\n    manifest = joinpath(dirname(Base.active_project()), "Manifest.toml")\n    return Dict(\n        "julia_version" => string(VERSION),\n        "packages" => packages,\n        "manifest_sha256" => isfile(manifest) ? bytes2hex(sha256(read(manifest))) : "",\n    )\nend\n\n# Resolve the model entry function: use the requested name, falling back to the\n# conventional build_model. This lets a request leave the entry implicit, or name a\n# custom entry that a given model file does not define (then build_model is used).\n# Load the user\'s model file into a throwaway module. Isolation keeps repeated\n# requests in the persistent worker from colliding on names (e.g. two models each\n# defining `const model_def`), and confines the model\'s globals to their own scope.\nfunction load_model_module(path)\n    mod = Module(gensym(:UserModel))\n    if endswith(lowercase(path), ".bugs")\n        # A bare BUGS program, parsed as the string form of `@bugs` parses it with\n        # dotted names kept, and given the entry a Julia model file would define.\n        model_def = JuliaBUGS.Parser._bugs_string_input(read(abspath(path), String), false)\n        Core.eval(mod, :(using JuliaBUGS))\n        Core.eval(mod, :(const model_def = $(Meta.quot(model_def))))\n        Core.eval(mod, :(build_model(data) = JuliaBUGS.compile(model_def, data)))\n    else\n        Base.include(mod, abspath(path))\n    end\n    return mod\nend\n\nfunction resolve_entry(mod, requested)\n    for name in (requested, "build_model")\n        name === nothing && continue\n        sym = Symbol(name)\n        # The model was just include\'d, so its bindings live in a newer world than\n        # this frame; resolve them in the latest world to avoid a Julia 1.12\n        # world-age warning on the access.\n        Base.invokelatest(isdefined, mod, sym) && return Base.invokelatest(getfield, mod, sym)\n    end\n    error("model file defines no entry function (looked for $(requested) and build_model)")\nend\n\n# Runs one request end to end. Returns {"ok": true, "provenance": ...} or\n# {"ok": false, "error": ..., "stage": ...}; never throws.\nfunction handle_request(request)\n    out = request["out"]\n    mode = get(request, "mode", "fit")\n    backend = get(get(request, "backend", Dict()), "id", "turing")\n    stage = "compile"\n    try\n        Random.seed!(Int(request["seed"]))\n        rng = StableRNG(Int(request["seed"]))\n        modelmod = load_model_module(request["model"]["file"])\n        entry = resolve_entry(modelmod, get(request["model"], "entry", nothing))\n\n        wire = if mode == "loglik"\n            if backend == "juliabugs"\n                model = Base.invokelatest(entry, bugs_namedtuple(request["data"]))\n                stage = "load_samples"\n                posterior = JSON.parsefile(request["samples"])\n                stage = "loglik"\n                Base.invokelatest(loglik_bugs, model, posterior)\n            else\n                data = ModelData(to_namedtuple(request["data"]))\n                model = Base.invokelatest(entry, data)\n                model = Base.invokelatest(condition_on_data, model, data)\n                stage = "load_samples"\n                chn = wire_to_vnchain(JSON.parsefile(request["samples"]), String[])\n                stage = "loglik"\n                pll = Base.invokelatest(Turing.DynamicPPL.pointwise_loglikelihoods, model, chn)\n                isempty(FlexiChains.parameters(pll)) &&\n                    error("the model has no observed variables to compute a log-likelihood for")\n                vnchain_to_wire(pll)\n            end\n        elseif mode == "predict"\n            if backend == "juliabugs"\n                model = Base.invokelatest(entry, bugs_namedtuple(request["data"]))\n                stage = "load_samples"\n                posterior = JSON.parsefile(request["samples"])\n                stage = "predict"\n                Base.invokelatest(predict_bugs, model, posterior, request["predict"]["targets"], rng)\n            else\n                model = Base.invokelatest(entry, ModelData(to_namedtuple(request["data"])))\n                stage = "load_samples"\n                rchn = wire_to_vnchain(JSON.parsefile(request["samples"]), request["predict"]["targets"])\n                stage = "predict"\n                pp = Base.invokelatest(predict, rng, model, rchn; include_all = false)\n                isempty(FlexiChains.parameters(pp)) &&\n                    error("no variables predicted; check that [predict].targets name unconditioned outcomes")\n                vnchain_to_wire(pp)\n            end\n        else\n            data = backend == "juliabugs" ? bugs_namedtuple(request["data"]) : ModelData(to_namedtuple(request["data"]))\n            parallel = get(request["sampler"], "parallel", "serial")\n            chains = Int(get(request["sampler"], "chains", 4))\n            if parallel == "distributed" && backend != "juliabugs"\n                # Every process needs the model\'s definitions under the same\n                # names; the module-per-request isolation gives way to Main.\n                stage = "distribute"\n                Base.invokelatest(setup_distributed, chains, request["model"]["file"])\n                modelmod = Main\n                entry = resolve_entry(Main, get(request["model"], "entry", nothing))\n            end\n            sampler_conf = apply_model_defaults(request["sampler"], modelmod)\n            draws = Int(request["sampler"]["draws"])\n            stage = "sample"\n            if backend == "juliabugs"\n                model = Base.invokelatest(entry, data)\n                chn = if get(sampler_conf, "algorithm", "NUTS") == "Prior"\n                    Base.invokelatest(sample_bugs_prior, model, draws, chains, rng)\n                else\n                    model = Base.invokelatest(\n                        prepare_bugs_model, model, sampler_conf,\n                        get(request["model"], "evaluation_mode", nothing),\n                    )\n                    sampler = Base.invokelatest(build_bugs_sampler, sampler_conf, model)\n                    warmup = Int(get(sampler_conf, "warmup", 1000))\n                    threads = parallel == "threads"\n                    # Reconstruction reads the plain BUGSModel; a gradient sampler runs wrapped.\n                    cb = get(request, "stream_draws", false) && !threads ?\n                        bugs_draw_streamer(\n                            base_bugs(model), sampler, draws,\n                            Int(get(request, "draw_batch_size", 25));\n                            keep = bugs_column_filter(request, model),\n                        ) : nothing\n                    Base.invokelatest(\n                        sample_bugs, model, sampler, warmup, draws, chains, rng;\n                        callback = cb, thin = Int(get(request["sampler"], "thin", 1)), threads,\n                        initial_params = Base.invokelatest(\n                            bugs_initial_params, model, sampler_conf,\n                        ),\n                    )\n                end\n                vnchain_to_wire(chn; keep = bugs_column_filter(request, model))\n            else\n                sampler, warmup = build_sampler(sampler_conf, modelmod)\n                # The draw streamer assumes chains arrive one at a time; with\n                # concurrent chains the caller must not request streaming.\n                cb = get(request, "stream_draws", false) && parallel == "serial" ?\n                    draw_streamer(draws, Int(get(request, "draw_batch_size", 25))) : nothing\n                extra = sampling_kwargs(request["sampler"], warmup, chains)\n                chn = Base.invokelatest(\n                    build_and_sample, entry, data, sampler, draws, chains, rng;\n                    callback = cb, extra, parallel,\n                )\n                vnchain_to_wire(chn)\n            end\n        end\n\n        stage = "write"\n        tmp = out * ".tmp"\n        open(tmp, "w") do io\n            JSON.print(io, wire)\n        end\n        mv(tmp, out; force = true)\n\n        return Dict("ok" => true, "provenance" => provenance())\n    catch err\n        return Dict("ok" => false, "error" => sprint(showerror, err), "stage" => stage)\n    end\nend\n',
+  "fitlib.jl": '# MCMC.js fit library, shared by the one-shot driver (driver.jl) and the\n# persistent worker (worker.jl). handle_request runs one fit or predict request\n# (Turing or JuliaBUGS) and writes the draws as the @mcmcjs/core samples\n# artifact (a flat JSON wire). This is the only place that touches the backend\n# chain type (FlexiChains), so a chain-type change is contained here.\nusing JSON\nusing Logging\nimport Distributed\nusing Random\nusing StableRNGs\nusing Turing\nusing Turing: VarName\nusing SHA\nusing Pkg\n# Imported (not `using`) so they do not pull `@model` etc. into Main and clash\n# with Turing\'s exports, which would break Turing model files on include.\nimport JuliaBUGS\nimport AdvancedHMC\n# Loading SliceSampling activates JuliaBUGS\'s extension for its derivative-free samplers.\nimport SliceSampling\nimport ForwardDiff\n# Loading Mooncake activates AbstractPPL\'s native extension for AutoMooncake.\nimport Mooncake\n# Loading ReverseDiff activates the DynamicPPL extension for AutoReverseDiff.\nimport ReverseDiff\nimport FlexiChains\nimport DimensionalData\n\n# Workers include this file to mirror the master\'s definitions (ModelData, the\n# helpers a deserialized model may reference) when sampling MCMCDistributed.\nconst FITLIB_FILE = @__FILE__\n\n# AbstractMCMC reports sampling progress through ProgressLogging (reachable via\n# Turing\'s dependency, no extra package in the managed env).\nconst ProgressLogging = Turing.AbstractMCMC.ProgressLogging\n\n# Where progress JSON lines go: the driver leaves this on stderr; the worker\n# points it at the client socket for the duration of a request.\nconst PROGRESS_IO = Ref{IO}(stderr)\n\n# Translates ProgressLogging records into one JSON line per update\n# ({"mcmcjs":"progress",...}). The TypeScript side filters these out of the\n# failure protocol\'s stderr buffer. Info-and-above records pass through to a\n# plain console logger; Debug records (AdvancedHMC step-size search) are dropped.\nstruct JSONProgressLogger <: Logging.AbstractLogger\n    fallback::Logging.AbstractLogger\n    last::Dict{Int,Float64}\nend\nJSONProgressLogger() =\n    JSONProgressLogger(Logging.ConsoleLogger(stderr, Logging.Info), Dict{Int,Float64}())\n\nLogging.min_enabled_level(::JSONProgressLogger) = Logging.BelowMinLevel\nLogging.shouldlog(::JSONProgressLogger, args...) = true\nLogging.catch_exceptions(::JSONProgressLogger) = true\n\nfunction emit_progress(logger::JSONProgressLogger, name, fraction, done)\n    m = match(r"Chain (\\d+) of (\\d+)", String(name))\n    chain = m === nothing ? 1 : parse(Int, m.captures[1])\n    of = m === nothing ? 1 : parse(Int, m.captures[2])\n    f = done ? 1.0 : fraction === nothing ? 0.0 : Float64(fraction)\n    # AbstractMCMC already steps by 1%; the dedupe guards chattier emitters.\n    if done || f - get(logger.last, chain, -1.0) >= 0.01\n        logger.last[chain] = f\n        println(\n            PROGRESS_IO[],\n            JSON.json(\n                Dict(\n                    "mcmcjs" => "progress",\n                    "chain" => chain,\n                    "of" => of,\n                    "fraction" => round(f; digits = 4),\n                    "done" => done,\n                ),\n            ),\n        )\n        flush(PROGRESS_IO[])\n    end\nend\n\nfunction Logging.handle_message(\n    logger::JSONProgressLogger, level, message, _module, group, id, file, line; kwargs...\n)\n    progress = message isa ProgressLogging.ProgressString ? message.progress :\n        message isa ProgressLogging.Progress ? message : nothing\n    if progress !== nothing\n        emit_progress(logger, progress.name, progress.fraction, progress.done)\n        return\n    end\n    if haskey(kwargs, :progress) && (kwargs[:progress] isa Real || kwargs[:progress] == "done")\n        value = kwargs[:progress]\n        emit_progress(logger, string(message), value == "done" ? nothing : value, value == "done")\n        return\n    end\n    level >= Logging.Info || return\n    Logging.handle_message(logger.fallback, level, message, _module, group, id, file, line; kwargs...)\nend\n\n# A Turing model file may declare the AD backend it needs by exporting, e.g.,\n# `const MCMC_DEFAULTS = (; adtype = "mooncake")`. A spec or flag adtype wins;\n# the model default fills in only when the request leaves adtype unset.\nfunction apply_model_defaults(sampler, mod)\n    haskey(sampler, "adtype") && return sampler\n    # Only the gradient samplers take an AD backend.\n    get(sampler, "algorithm", "NUTS") in ("NUTS", "HMC", "HMCDA", "Gibbs", "External") ||\n        return sampler\n    Base.invokelatest(isdefined, mod, :MCMC_DEFAULTS) || return sampler\n    defaults = Base.invokelatest(getfield, mod, :MCMC_DEFAULTS)\n    hasproperty(defaults, :adtype) || return sampler\n    merged = copy(sampler)\n    merged["adtype"] = String(defaults.adtype)\n    return merged\nend\n\nfunction build_adtype(name)\n    name == "forwarddiff" && return Turing.ADTypes.AutoForwardDiff()\n    name == "reversediff" && return Turing.ADTypes.AutoReverseDiff()\n    name == "mooncake" && return Turing.ADTypes.AutoMooncake(; config = nothing)\n    error("unsupported adtype: $name")\nend\n\nfunction build_sampler(sampler, modelmod = nothing)\n    algorithm = get(sampler, "algorithm", "NUTS")\n    # Prior draws are iid: no warmup, no adaptation. The JuliaBUGS path samples\n    # ancestrally (sample_bugs_prior) instead of going through a sampler object.\n    algorithm == "Prior" && return Turing.Prior(), 0\n    warmup = Int(get(sampler, "warmup", 1000))\n    adapt_delta = Float64(get(sampler, "adapt_delta", 0.8))\n    algorithm == "MH" && return Turing.MH(), warmup\n    algorithm == "ESS" && return Turing.ESS(), warmup\n    algorithm == "SMC" && return Turing.SMC(), warmup\n    algorithm == "PG" && return Turing.PG(Int(sampler["particles"])), warmup\n    adkw = haskey(sampler, "adtype") ? (; adtype = build_adtype(sampler["adtype"])) : (;)\n    algorithm == "NUTS" && return Turing.NUTS(warmup, adapt_delta; adkw...), warmup\n    algorithm == "HMC" &&\n        return Turing.HMC(Float64(sampler["step_size"]), Int(sampler["leapfrog_steps"]); adkw...),\n        warmup\n    algorithm == "HMCDA" &&\n        return Turing.HMCDA(warmup, adapt_delta, Float64(sampler["lambda"]); adkw...), warmup\n    algorithm == "Gibbs" && return build_gibbs(sampler, adkw, warmup), warmup\n    if algorithm == "External"\n        modelmod === nothing && error("the External algorithm applies to Turing models only")\n        Base.invokelatest(isdefined, modelmod, :MCMC_SAMPLER) ||\n            error("algorithm External needs the model file to define MCMC_SAMPLER")\n        ext = Base.invokelatest(getfield, modelmod, :MCMC_SAMPLER)\n        return Turing.externalsampler(ext; adkw...), warmup\n    end\n    error("unsupported sampler algorithm: $algorithm")\nend\n\n# One Gibbs component: the block\'s variables get the block\'s sampler. A single\n# variable keys by symbol, several by tuple, matching Turing\'s constructor.\nfunction block_sampler(block, adkw, warmup)\n    algorithm = get(block, "algorithm", "NUTS")\n    adapt_delta = Float64(get(block, "adapt_delta", 0.8))\n    algorithm == "MH" && return Turing.MH()\n    algorithm == "ESS" && return Turing.ESS()\n    algorithm == "PG" && return Turing.PG(Int(block["particles"]))\n    algorithm == "NUTS" && return Turing.NUTS(warmup, adapt_delta; adkw...)\n    algorithm == "HMC" &&\n        return Turing.HMC(Float64(block["step_size"]), Int(block["leapfrog_steps"]); adkw...)\n    algorithm == "HMCDA" &&\n        return Turing.HMCDA(warmup, adapt_delta, Float64(block["lambda"]); adkw...)\n    error("unsupported Gibbs block algorithm: $algorithm")\nend\n\nfunction build_gibbs(sampler, adkw, warmup)\n    pairs = map(sampler["blocks"]) do block\n        vars = Symbol.(block["variables"])\n        key = length(vars) == 1 ? vars[1] : Tuple(vars)\n        key => block_sampler(block, adkw, warmup)\n    end\n    return Turing.Gibbs(pairs...)\nend\n\n# Extra keyword arguments for AbstractMCMC.sample, from the request\'s sampler\n# table: thinning, burn-in for the non-adaptive samplers (NUTS and HMCDA discard\n# their own adaptation), and named starting values replicated across chains.\nfunction sampling_kwargs(sampler, warmup, chains)\n    kw = (;)\n    thin = Int(get(sampler, "thin", 1))\n    thin > 1 && (kw = merge(kw, (; thinning = thin)))\n    algorithm = get(sampler, "algorithm", "NUTS")\n    if algorithm in ("MH", "HMC", "ESS", "PG", "Gibbs", "External") && warmup > 0\n        kw = merge(kw, (; discard_initial = warmup))\n    end\n    # AdvancedHMC-style external samplers adapt only when told how many steps to\n    # use; without n_adapts a chain can freeze at its initial point.\n    if algorithm == "External" && warmup > 0\n        kw = merge(kw, (; n_adapts = warmup))\n    end\n    # NUTS/HMCDA blocks inside Gibbs adapt only through the sample-level nadapts\n    # keyword (the constructor\'s count is ignored there); without it the block\n    # never tunes its step size and can freeze.\n    if algorithm == "Gibbs" && warmup > 0\n        blocks = get(sampler, "blocks", Any[])\n        if any(get(b, "algorithm", "NUTS") in ("NUTS", "HMCDA") for b in blocks)\n            kw = merge(kw, (; nadapts = warmup))\n        end\n    end\n    if haskey(sampler, "initial_params")\n        nt = (; (Symbol(k) => narrow(v) for (k, v) in sampler["initial_params"])...)\n        strategy = Turing.DynamicPPL.InitFromParams(nt)\n        kw = merge(kw, (; initial_params = fill(strategy, chains)))\n    end\n    return kw\nend\n\n# Binds the data so a model can read a variable as a property (`data.y`) or by\n# index (`data["y"]` / `data[:y]`), with `haskey`/`keys` supported, so models\n# written in either idiom run unchanged. The underlying NamedTuple is reached\n# via getfield to avoid colliding with a data variable also named `nt`.\nstruct ModelData\n    nt::NamedTuple\nend\nBase.getproperty(d::ModelData, k::Symbol) = getproperty(getfield(d, :nt), k)\nBase.getindex(d::ModelData, k::Symbol) = getproperty(getfield(d, :nt), k)\nBase.getindex(d::ModelData, k::AbstractString) = getproperty(getfield(d, :nt), Symbol(k))\nBase.haskey(d::ModelData, k::Symbol) = haskey(getfield(d, :nt), k)\nBase.haskey(d::ModelData, k::AbstractString) = haskey(getfield(d, :nt), Symbol(k))\nBase.keys(d::ModelData) = keys(getfield(d, :nt))\nBase.propertynames(d::ModelData) = propertynames(getfield(d, :nt))\n\n# JuliaBUGS requires dense arrays with a concrete numeric eltype, but JSON parses\n# them as Vector{Any} (and nested arrays as vectors of vectors). narrow promotes a\n# numeric array to a concrete eltype and stacks equal-sized nested arrays into a\n# dense array; an empty array becomes Float64[].\nfunction narrow(v::AbstractVector)\n    isempty(v) && return Float64[]\n    elems = [narrow(x) for x in v]\n    if all(e -> e isa AbstractArray, elems) && allequal(size.(elems))\n        return stack(elems; dims = 1)\n    end\n    return eltype(elems) <: Real && !isconcretetype(eltype(elems)) ? float.(elems) : elems\nend\nnarrow(x) = x\n\n# JSON null arrives as `nothing`; map it to `missing`, which both PPLs read as an\n# unobserved entry: a sampling statement rather than an observation.\nto_missing(x) = x === nothing ? missing : (x isa AbstractVector ? map(to_missing, x) : x)\nto_namedtuple(data) = (; (Symbol(k) => to_missing(v) for (k, v) in data)...)\n\n# JuliaBUGS backs an array\'s unobserved entries with the eltype of its observed\n# ones, so an integer censoring time would leave a continuous latent an Int slot\n# to live in. Float64 holds a count just as exactly, so it holds either.\nfunction allow_missing(v::AbstractArray)\n    any(ismissing, v) || return v\n    return convert(AbstractArray{Union{Missing,Float64}}, v)\nend\nallow_missing(x) = x\n\nbugs_namedtuple(data) =\n    (; (Symbol(k) => allow_missing(narrow(to_missing(v))) for (k, v) in data)...)\n\n# Rebuild a posterior VNChain (latents only) from our samples wire so it can feed\n# Turing\'s predict. Scalar leaves are regrouped into their array-valued VarName\n# (theta[1..8] -> @varname(theta) holding an 8-vector), so predict matches the\n# model\'s parameters exactly instead of relying on leaf reconstruction. Target\n# outcome columns are excluded.\nfunction wire_to_vnchain(wire, targets)\n    sz = wire["size"]\n    nIter, total, nChains = Int(sz[1]), Int(sz[2]), Int(sz[3])\n    flat = wire["value_flat"]\n    index = Dict(n => i for (i, n) in enumerate(wire["parameters"]))\n    is_target(n) = any(t -> n == t || startswith(n, t * "["), targets)\n    keep = [n for n in wire["name_map"]["parameters"] if !is_target(n)]\n    cell(name, i, c) = begin\n        p = index[name]\n        v = flat[i + (p - 1) * nIter + (c - 1) * nIter * total]\n        v === nothing ? NaN : Float64(v)\n    end\n    base_of(n) = (b = findfirst(\'[\', n); b === nothing ? n : n[1:prevind(n, b)])\n    idx_of(n) = begin\n        b = findfirst(\'[\', n)\n        b === nothing && return Int[]\n        inner = n[nextind(n, b):prevind(n, findlast(\']\', n))]\n        parse.(Int, split(inner, \',\'))\n    end\n    groups = Dict{String,Vector{String}}()\n    for n in keep\n        push!(get!(groups, base_of(n), String[]), n)\n    end\n    dict = Dict{FlexiChains.ParameterOrExtra{<:VarName},Array}()\n    for (base, names) in groups\n        vn = eval(:(Turing.@varname($(Meta.parse(base)))))\n        if length(names) == 1 && isempty(idx_of(names[1]))\n            m = Matrix{Float64}(undef, nIter, nChains)\n            for c in 1:nChains, i in 1:nIter\n                m[i, c] = cell(names[1], i, c)\n            end\n            dict[FlexiChains.Parameter(vn)] = m\n        else\n            idxs = [idx_of(n) for n in names]\n            D = length(idxs[1])\n            dims = ntuple(d -> maximum(ix[d] for ix in idxs), D)\n            m = Matrix{Array{Float64,D}}(undef, nIter, nChains)\n            for c in 1:nChains, i in 1:nIter\n                a = Array{Float64,D}(undef, dims...)\n                for (n, ix) in zip(names, idxs)\n                    a[ix...] = cell(n, i, c)\n                end\n                m[i, c] = a\n            end\n            dict[FlexiChains.Parameter(vn)] = m\n        end\n    end\n    return FlexiChains.FlexiChain{VarName}(nIter, nChains, dict)\nend\n\n# Expand one sampler transition to canonical scalar leaves (theta -> theta[1], ...),\n# the same names the final samples file uses, so streamed batches reconstruct it.\n# Sampler statistics (acceptance rate, tree depth, ...) ride along under the same\n# names the samples file records as internals, so consumers get per-draw\n# diagnostics without a second channel; Bool stats become 0/1.\nfunction flatten_draw(transition)\n    out = Pair{String,Float64}[]\n    for (vn, val) in pairs(transition.params)\n        for (leaf, leafval) in Turing.DynamicPPL.varname_and_value_leaves(vn, val)\n            push!(out, string(leaf) => Float64(leafval))\n        end\n    end\n    if hasproperty(transition, :stats)\n        for (name, value) in pairs(transition.stats)\n            value isa Real && push!(out, string(name) => Float64(value))\n        end\n    end\n    return out\nend\n\n# A per-draw callback that emits {"mcmcjs":"draws",...} batches on PROGRESS_IO as\n# sampling proceeds. AbstractMCMC passes the 1-based chain index as `chain_number`;\n# each batch carries a per-chain monotonic seq, and a chain\'s batches concatenate\n# (by leaf name) to the final samples file. Assumes the callback is not invoked\n# concurrently across chains (true for the MCMCSerial path build_and_sample uses).\nfunction draw_streamer(draws_per_chain::Int, batch_size::Int)\n    chain = Ref(-1)\n    seq = Ref(0)\n    names = String[]\n    buffer = Dict{String,Vector{Float64}}()\n    filled = Ref(0)\n    function emit(iteration)\n        filled[] == 0 && return\n        cols = Dict{String,Vector{Float64}}(n => copy(buffer[n]) for n in names)\n        println(\n            PROGRESS_IO[],\n            JSON.json(\n                Dict(\n                    "mcmcjs" => "draws",\n                    "chain" => chain[],\n                    "seq" => seq[],\n                    "iteration" => iteration,\n                    "draws" => cols,\n                ),\n            ),\n        )\n        flush(PROGRESS_IO[])\n        seq[] += 1\n        for n in names\n            empty!(buffer[n])\n        end\n        filled[] = 0\n    end\n    return function (_rng, _model, _sampler, transition, _state, iteration; chain_number = 1, _kwargs...)\n        c = Int(chain_number) - 1\n        if c != chain[]\n            chain[] = c\n            seq[] = 0\n        end\n        leaves = flatten_draw(transition)\n        if isempty(names)\n            for (n, _) in leaves\n                push!(names, n)\n                buffer[n] = Float64[]\n            end\n        end\n        for (n, v) in leaves\n            push!(get!(buffer, n, Float64[]), v)\n        end\n        filled[] += 1\n        if filled[] >= batch_size || iteration >= draws_per_chain\n            emit(iteration)\n        end\n    end\nend\n\n# Turing observes a variable only when its name is a model argument. A dict-reading\n# model (`y = data["y"]; y[i] ~ dist`) would otherwise SAMPLE its outcome instead of\n# observing it, so condition the built model on the data columns to turn each such\n# `~` into an observation. Columns that are already model arguments are skipped: they\n# are observed by construction, and conditioning one that is also an argument errors.\n# Do not probe the model to find latent columns (e.g. via VarInfo): evaluating a\n# dict-reading model assigns prior draws into the array the data is read from,\n# corrupting it before we condition. Predictor columns carry no `~`, so conditioning\n# on them is a harmless no-op.\nfunction condition_on_data(model, data)\n    nt = data isa ModelData ? getfield(data, :nt) : data\n    nt isa NamedTuple || return model\n    argnames = keys(model.args)\n    pairs = [k => getproperty(nt, k) for k in keys(nt) if Base.isidentifier(string(k)) && !(k in argnames)]\n    isempty(pairs) && return model\n    return Turing.DynamicPPL.condition(model, (; pairs...))\nend\n\n# Build the model and sample in one call so both run in the latest world age:\n# the model methods are defined by `include` at runtime, so a plain call from\n# this (older) world would fail with "method too new". invokelatest fixes that.\n# Returns Turing\'s default chain type, a FlexiChain. With a callback, draws stream.\nfunction build_and_sample(\n    entry, data, sampler, draws, chains, rng; callback = nothing, extra = (;), parallel = "serial"\n)\n    model = condition_on_data(entry(data), data)\n    kw = callback === nothing ? extra : merge(extra, (; callback))\n    ensemble = parallel == "threads" ? MCMCThreads() :\n        parallel == "distributed" ? MCMCDistributed() : MCMCSerial()\n    return Logging.with_logger(JSONProgressLogger()) do\n        sample(rng, model, sampler, ensemble, draws, chains; progress = true, kw...)\n    end\nend\n\n# Distributed chains need the model\'s definitions on every process: workers get\n# this file (ModelData and friends), then all processes include the model file\n# into Main so the serialized model\'s references resolve identically everywhere.\nfunction setup_distributed(chains, model_file)\n    missing_workers = chains - Distributed.nworkers()\n    if Distributed.nprocs() == 1 || missing_workers > 0\n        Distributed.addprocs(\n            Distributed.nprocs() == 1 ? chains : missing_workers;\n            exeflags = ["--project=$(Base.active_project())", "--startup-file=no"],\n        )\n        Distributed.remotecall_eval(\n            Main, Distributed.workers(), :(Base.include(Main, $FITLIB_FILE))\n        )\n    end\n    Distributed.remotecall_eval(Main, Distributed.procs(), :(Base.include(Main, $model_file)))\nend\n\n# The internals section: one scalar column per sampler statistic, as\n# (name, (iter, chain) -> value) pairs. An array-valued statistic (a slice\n# sampler reports a proposal count per coordinate) splits into name[i] columns\n# the way array parameters do, so nothing the sampler reported is dropped.\nfunction extra_columns(chn)\n    cols = Tuple{String,Function}[]\n    for e in FlexiChains.extras(chn)\n        m = chn[e]\n        name = string(Symbol(e))\n        if eltype(m) <: Union{Missing,Real}\n            push!(cols, (name, (i, c) -> m[i, c]))\n        elseif eltype(m) <: AbstractArray && eltype(eltype(m)) <: Union{Missing,Real}\n            for idx in eachindex(m[1, 1])\n                push!(cols, ("$name[$idx]", (i, c) -> m[i, c][idx]))\n            end\n        end\n    end\n    return cols\nend\n\n# FlexiChains-native wire writer. DimArray(chn) splits array-valued parameters\n# into scalar leaves (theta -> theta[1], theta[2]) in the (iter, chain, param)\n# orientation; the sampler\'s statistics become the internals section. `keep`\n# decides by leaf name which columns are written; nothing keeps them all.\nfunction vnchain_to_wire(chn; keep = nothing)\n    da = DimensionalData.DimArray(chn)\n    names = string.(collect(DimensionalData.lookup(da, :param)))\n    arr = parent(da)\n    nIter, nChains, _ = size(arr)\n    kept = keep === nothing ? eachindex(names) : findall(keep, names)\n    pnames = names[kept]\n    nParams = length(kept)\n\n    extras = extra_columns(chn)\n    enames = first.(extras)\n    total = nParams + length(extras)\n\n    flat = Vector{Union{Float64,Nothing}}(undef, nIter * total * nChains)\n    # JSON has no Inf/NaN; a non-finite draw (e.g. 1/sqrt(tau) under a diffuse\n    # prior) becomes null, which the samples parser reads back as NaN.\n    cell(v) = v === missing || !isfinite(v) ? nothing : Float64(v)\n    for c in 1:nChains, (p, src) in enumerate(kept), i in 1:nIter\n        flat[i + (p - 1) * nIter + (c - 1) * nIter * total] = cell(arr[i, c, src])\n    end\n    for (k, (_, draw)) in enumerate(extras)\n        p = nParams + k\n        for c in 1:nChains, i in 1:nIter\n            flat[i + (p - 1) * nIter + (c - 1) * nIter * total] = cell(draw(i, c))\n        end\n    end\n\n    return Dict(\n        "size" => [nIter, total, nChains],\n        "value_flat" => flat,\n        "parameters" => vcat(pnames, enames),\n        "name_map" => Dict("parameters" => pnames, "internals" => enames),\n    )\nend\n\n# A BUGSModel carries its own `base_model` field (the unconditioned model, or\n# nothing), so unwrapping has to test the wrapper\'s type, not for the field.\nbase_bugs(model) = model isa JuliaBUGS.BUGSModelWithGradient ? model.base_model : model\n\n# `[model].monitor` names the deterministic quantities worth storing; the model\'s\n# parameters are always stored. Unset keeps every column the chain carries. The\n# graph\'s parameter list is read rather than `model_parameters`, which in the\n# marginalized mode leaves out the discrete latents the chain still carries.\nfunction bugs_column_filter(request, model)\n    monitor = get(request["model"], "monitor", nothing)\n    monitor === nothing && return nothing\n    keep = Set{String}(String.(monitor))\n    for vn in base_bugs(model).graph_evaluation_data.model_parameters\n        push!(keep, String(JuliaBUGS.AbstractPPL.getsym(vn)))\n    end\n    return name -> first(split(name, \'[\'; limit = 2)) in keep\nend\n\n# JuliaBUGS samplers that propose in the evaluation environment, so they move the\n# discrete latents themselves rather than needing them summed out.\nconst ENV_BASED_BUGS_SAMPLERS = ("MH", "Gibbs")\n\n# Switches a model to the evaluation mode the spec names. The generated and\n# marginalized modes read parameters in unconstrained space, so both need a\n# transformed model first. invokelatest is needed because JuliaBUGS `Core.eval`s\n# the model\'s node functions while compiling, putting them in a newer world than\n# this frame; the generated mode `Core.eval`s a log-density function here too.\nfunction set_bugs_mode(model, name)\n    name == "graph" &&\n        return Base.invokelatest(JuliaBUGS.set_evaluation_mode, model, JuliaBUGS.UseGraph())\n    mode = name == "generated" ? JuliaBUGS.UseGeneratedLogDensityFunction() :\n        name == "marginalized" ? JuliaBUGS.UseAutoMarginalization() :\n        error("unsupported evaluation mode: $name")\n    return Base.invokelatest(\n        JuliaBUGS.set_evaluation_mode, JuliaBUGS.settrans(model, true), mode,\n    )\nend\n\n# Named starting values, in constrained space, as the spec records them. A name\n# the model does not have at all is an error, since `initialize!` would ignore it\n# silently. A name that is a variable but not a parameter, an observed node or a\n# deterministic one, is left out, as BUGS does with such initial values; the\n# published inits of the classic examples carry them.\nfunction initialize_bugs_model(model, sampler)\n    haskey(sampler, "initial_params") || return model\n    gd = base_bugs(model).graph_evaluation_data\n    name(vn) = String(JuliaBUGS.AbstractPPL.getsym(vn))\n    parameters = Set(name.(gd.model_parameters))\n    known = Set(name.(gd.sorted_nodes))\n    for k in keys(sampler["initial_params"])\n        k in known || error("initial_params names $k, which is not a variable of this model")\n    end\n    inits = Dict(k => v for (k, v) in sampler["initial_params"] if k in parameters)\n    isempty(inits) && return model\n    # A JSON `0` arrives as an integer, and a continuous parameter initialized with it\n    # gets an integer slot that the generated log density cannot write a float into.\n    types = bugs_node_types(base_bugs(model))\n    continuous(k) = all(t == :continuous for (vn, t) in types if name(vn) == k)\n    as_float(v) = v isa AbstractArray{<:Real} || v isa Real ? float(v) : v\n    values = bugs_namedtuple(inits)\n    values = (; (k => (continuous(String(k)) ? as_float(v) : v) for (k, v) in pairs(values))...)\n    model = Base.invokelatest(JuliaBUGS.initialize!, model, values)\n    return finite_start(model, Set(String.(keys(values))))\nend\n\n# Published initial values rarely cover every parameter, and the rest come from prior\n# draws, which under vague priors put Magnesium\'s start at -Inf every time. A start that\n# is not finite has those uncovered parameters redrawn uniformly on (-2, 2) in\n# unconstrained space, as Stan starts, keeping the given values.\nfunction finite_start(model, given; attempts = 50)\n    model.transformed || return model\n    LDP = JuliaBUGS.LogDensityProblems\n    x = Base.invokelatest(JuliaBUGS.getparams, model)\n    isfinite(Base.invokelatest(LDP.logdensity, model, x)) && return model\n    vars = model.evaluation_mode isa JuliaBUGS.UseAutoMarginalization ?\n        model.marginalization_cache.continuous_model_parameters :\n        Base.invokelatest(JuliaBUGS.model_parameters, model)\n    rng = StableRNG(1)\n    for _ in 1:attempts\n        z = copy(x)\n        pos = 1\n        for vn in vars\n            len = model.transformed_var_lengths[vn]\n            String(JuliaBUGS.AbstractPPL.getsym(vn)) in given ||\n                (z[pos:(pos + len - 1)] .= 4 .* rand(rng, len) .- 2)\n            pos += len\n        end\n        isfinite(Base.invokelatest(LDP.logdensity, model, z)) &&\n            return Base.invokelatest(JuliaBUGS.initialize!, model, z)\n    end\n    return model\nend\n\n# With no evaluation mode chosen, a gradient sampler gets the discrete finite\n# latents summed out of the log density, since it cannot move them itself. A model\n# that is discrete throughout has nothing left for it to sample.\nfunction marginalize_if_discrete(base)\n    base.evaluation_mode isa JuliaBUGS.UseGraph || return base\n    marginalized = set_bugs_mode(base, "marginalized")\n    cache = marginalized.marginalization_cache\n    (cache === nothing || cache.n_discrete_finite == 0) && return base\n    Base.invokelatest(JuliaBUGS.LogDensityProblems.dimension, marginalized) == 0 && error(\n        "every parameter of this model is discrete, which a gradient sampler cannot move; use the MH sampler",\n    )\n    return marginalized\nend\n\n# An environment-based sampler starts from the model\'s evaluation environment and\n# accepts on `logp_proposed - logp_current`, which is NaN when both are -Inf: from\n# an impossible starting point the chain can never move. Say so, with the fix,\n# rather than return draws that never left the start.\nfunction check_bugs_start(model, sampler)\n    logp = try\n        last(Base.invokelatest(JuliaBUGS.AbstractPPL.evaluate!!, model))\n    catch\n        -Inf\n    end\n    isfinite(logp) && return model\n    detail = haskey(sampler, "initial_params") ?\n        "the given initial_params have zero probability under the model" :\n        "the model\'s default starting values have zero probability under the data; " *\n        "set [sampler.initial_params] to a state the data allows"\n    return error("$(get(sampler, "algorithm", "MH")) cannot start: $detail")\nend\n\n# Applies the request\'s options to a compiled model: the spec\'s evaluation mode\n# over whatever the model file chose, the initial values, and the AD backend. The\n# gradient wrapper holds a prepared gradient over one base model, so it is rebuilt\n# whenever the base changes.\nfunction prepare_bugs_model(model, sampler, mode_name)\n    base = base_bugs(model)\n    if get(sampler, "algorithm", "NUTS") in ENV_BASED_BUGS_SAMPLERS\n        # Marginalizing would sum out the very latents these samplers propose, so\n        # they always run against the plain model under graph evaluation.\n        base = initialize_bugs_model(set_bugs_mode(base, "graph"), sampler)\n        return check_bugs_start(base, sampler)\n    end\n    base = mode_name === nothing ? marginalize_if_discrete(base) : set_bugs_mode(base, mode_name)\n    # A derivative-free sampler wants the plain model: preparing a gradient it\n    # never calls costs a compile, which for Mooncake runs into minutes.\n    get(sampler, "algorithm", "NUTS") == "Slice" && return initialize_bugs_model(base, sampler)\n    if !haskey(sampler, "adtype") && !(model isa JuliaBUGS.BUGSModelWithGradient) &&\n       mode_name === nothing\n        checked = checked_gradient(base, sampler)\n        checked === nothing || return checked\n    end\n    adtype = haskey(sampler, "adtype") ? build_adtype(sampler["adtype"]) :\n        model isa JuliaBUGS.BUGSModelWithGradient ? model.adtype :\n        Turing.ADTypes.AutoForwardDiff()\n    base = initialize_bugs_model(base, sampler)\n    return Base.invokelatest(JuliaBUGS.BUGSModelWithGradient, base, adtype)\nend\n\n# With neither an evaluation mode nor an AD backend chosen, each candidate gradient is\n# tried fastest first, and the first whose gradient at the starting point matches central\n# differences of the same function is used. On the BUGS examples the generated log\n# density under Mooncake takes 10 to 740 times less per gradient than ForwardDiff on the\n# graph, and on marginalized models ForwardDiff is the faster by 13 to 18 times.\n# Neither is right everywhere: ForwardDiff\'s Poisson derivative at rate zero is NaN\n# (Leuk, Hearts) and Mooncake\'s Birats gradient is 6% off. Returns nothing when no\n# candidate passes, and the model is then fitted as before.\nfunction checked_gradient(base, sampler)\n    forwarddiff = Turing.ADTypes.AutoForwardDiff()\n    mooncake = Turing.ADTypes.AutoMooncake(; config = nothing)\n    candidates = if base.evaluation_mode isa JuliaBUGS.UseGraph\n        (("generated", mooncake),)\n    elseif base.evaluation_mode isa JuliaBUGS.UseAutoMarginalization\n        ((nothing, forwarddiff), (nothing, mooncake))\n    else\n        ()\n    end\n    for (mode, adtype) in candidates\n        try\n            # The generated function writes into the evaluation environment\'s arrays,\n            # so each attempt gets its own copy and a failed one leaves `base` unchanged.\n            candidate = deepcopy(base)\n            if mode !== nothing\n                candidate = set_bugs_mode(candidate, mode)\n                candidate.evaluation_mode isa JuliaBUGS.UseGeneratedLogDensityFunction || continue\n            end\n            candidate = initialize_bugs_model(candidate, sampler)\n            wrapped = Base.invokelatest(JuliaBUGS.BUGSModelWithGradient, candidate, adtype)\n            x = Base.invokelatest(JuliaBUGS.getparams, candidate)\n            gradient_matches_differences(wrapped, x) && return wrapped\n        catch\n        end\n    end\n    return nothing\nend\n\nfunction gradient_matches_differences(wrapped, x; rtol = 1e-4)\n    LDP = JuliaBUGS.LogDensityProblems\n    ld, grad = Base.invokelatest(LDP.logdensity_and_gradient, wrapped, x)\n    (isfinite(ld) && all(isfinite, grad)) || return false\n    f(z) = Base.invokelatest(LDP.logdensity, wrapped, z)\n    diffs = similar(x)\n    for i in eachindex(x)\n        h = 1e-6 * max(1.0, abs(x[i]))\n        step = zero(x)\n        step[i] = h\n        diffs[i] = (f(x .+ step) - f(x .- step)) / 2h\n    end\n    all(isfinite, diffs) || return false\n    return sqrt(sum(abs2, grad .- diffs)) <= rtol * max(sqrt(sum(abs2, diffs)), 1.0)\nend\n\n# AdvancedHMC starts from a fresh draw unless handed a starting vector, so an\n# initialized model\'s values reach a gradient sampler through this. The\n# environment-based samplers start from the model\'s own environment, which\n# `initialize!` has already set.\nfunction bugs_initial_params(model, sampler)\n    haskey(sampler, "initial_params") || return nothing\n    get(sampler, "algorithm", "NUTS") in ENV_BASED_BUGS_SAMPLERS && return nothing\n    return Base.invokelatest(JuliaBUGS.getparams, base_bugs(model))\nend\n\n# The AdvancedHMC sampler for a NUTS/HMC/HMCDA configuration, whole or per Gibbs\n# block; nothing for any other algorithm. Adaptation runs off `sample`\'s n_adapts,\n# so no constructor here takes a step count.\nfunction bugs_hmc_sampler(conf)\n    algorithm = get(conf, "algorithm", "NUTS")\n    adapt_delta = Float64(get(conf, "adapt_delta", 0.8))\n    algorithm == "NUTS" && return AdvancedHMC.NUTS(adapt_delta)\n    algorithm == "HMC" &&\n        return AdvancedHMC.HMC(Float64(conf["step_size"]), Int(conf["leapfrog_steps"]))\n    algorithm == "HMCDA" && return AdvancedHMC.HMCDA(adapt_delta, Float64(conf["lambda"]))\n    return nothing\nend\n\n# SliceSampling\'s univariate samplers move one coordinate at a time, so a\n# multi-parameter target needs a multivariate strategy around them. RandPermGibbs\n# cycles the coordinates in a random order, and reduces to the plain univariate\n# update when a Gibbs block leaves only one.\nfunction bugs_slice_sampler(conf)\n    width = Float64(conf["slice_width"])\n    return SliceSampling.RandPermGibbs(SliceSampling.SliceSteppingOut(width))\nend\n\n# The support of each variable, as `Gibbs` itself classifies it. The stored value\n# does not say: JuliaBUGS keeps a latent count in a Float64 array, so a count\n# reads as continuous and would draw a Gaussian proposal it cannot represent.\nfunction bugs_node_types(model)\n    gd = model.graph_evaluation_data\n    return Dict(zip(gd.sorted_nodes, Base.invokelatest(JuliaBUGS.Model._compute_node_types, model)))\nend\n\n# A Gaussian step never lands on an integer, so a block of counts gets a lattice\n# walk. `Gibbs` draws a finite discrete block exactly instead, whatever it is\n# given here.\nfunction bugs_mh_kernel(model, vns, node_types)\n    expanded = JuliaBUGS.expand_variables(vns, model.graph_evaluation_data.model_parameters)\n    all(vn -> get(node_types, vn, :continuous) === :discrete_infinite, expanded) ||\n        return JuliaBUGS.AdvancedMH.RobustAdaptiveMetropolis()\n    return JuliaBUGS.AdvancedMH.RWMH([DiscreteUniform(-1, 1) for _ in expanded])\nend\n\n# One block per parameter, each with the kernel its own support calls for. The\n# convenience `Gibbs(model, sampler)` gives every block the same one.\nfunction bugs_single_site_mh(model)\n    node_types = bugs_node_types(model)\n    pairs = [\n        vn => bugs_mh_kernel(model, [vn], node_types) for\n        vn in JuliaBUGS.model_parameters(model)\n    ]\n    return JuliaBUGS.Gibbs(model, JuliaBUGS.OrderedDict(pairs))\nend\n\nbugs_varname(name) = eval(:(Turing.@varname($(Meta.parse(name)))))\n\n# One spec block becomes one entry of JuliaBUGS\'s sampler map, keyed by the\n# block\'s variables together; gradient blocks must carry their AD backend as a\n# tuple. JuliaBUGS checks that the map covers every parameter exactly once.\nfunction build_bugs_gibbs(sampler, model)\n    adtype = build_adtype(get(sampler, "adtype", "forwarddiff"))\n    node_types = bugs_node_types(model)\n    pairs = map(sampler["blocks"]) do block\n        vars = [bugs_varname(v) for v in block["variables"]]\n        key = length(vars) == 1 ? vars[1] : vars\n        algorithm = get(block, "algorithm", "NUTS")\n        component = algorithm == "MH" ? bugs_mh_kernel(model, vars, node_types) :\n            algorithm == "Slice" ? bugs_slice_sampler(block) :\n            (bugs_hmc_sampler(block), adtype)\n        key => component\n    end\n    return JuliaBUGS.Gibbs(model, JuliaBUGS.OrderedDict(pairs))\nend\n\n# Unlike the Turing path this needs the model: JuliaBUGS\'s Gibbs validates its\n# sampler map against the model\'s parameters as it is constructed.\nfunction build_bugs_sampler(sampler, model)\n    hmc = bugs_hmc_sampler(sampler)\n    hmc === nothing || return hmc\n    algorithm = get(sampler, "algorithm", "NUTS")\n    algorithm == "Slice" && return bugs_slice_sampler(sampler)\n    # Single-site Metropolis over every parameter: the WinBUGS-shaped sampler, and\n    # the route to discrete latents that marginalization declines.\n    algorithm == "MH" && return bugs_single_site_mh(model)\n    algorithm == "Gibbs" && return build_bugs_gibbs(sampler, model)\n    return error("the juliabugs backend does not support the $algorithm sampler")\nend\n\n# JuliaBUGS compiles the model at runtime, so building and sampling must run in\n# separate latest-world frames; merging them reintroduces a world-age error.\n# Returns a FlexiChain like the Turing path; gen_chains recovers generated\n# quantities (unobserved nodes with no observed descendants) after sampling.\n# With a callback, draws stream (see bugs_draw_streamer).\nfunction sample_bugs(\n    model, sampler, warmup, draws, chains, rng;\n    callback = nothing, thin = 1, threads = false, initial_params = nothing,\n)\n    kw = callback === nothing ? (;) : (; callback)\n    thin > 1 && (kw = merge(kw, (; thinning = thin)))\n    # Ensemble sampling wants one starting point per chain; every chain starts from\n    # the values the spec named, and diverges from there through its own stream.\n    initial_params === nothing ||\n        (kw = merge(kw, (; initial_params = fill(initial_params, chains))))\n    ensemble = threads ? JuliaBUGS.AbstractMCMC.MCMCThreads() : JuliaBUGS.AbstractMCMC.MCMCSerial()\n    return Logging.with_logger(JSONProgressLogger()) do\n        JuliaBUGS.AbstractMCMC.sample(\n            rng, model, sampler, ensemble, draws, chains;\n            chain_type = FlexiChains.VNChain, n_adapts = warmup, discard_initial = warmup,\n            progress = true, kw...,\n        )\n    end\nend\n\n# JuliaBUGS prior sampling: each draw is one ancestral pass (evaluate!! with an\n# rng samples every unobserved stochastic node from its prior and recomputes the\n# deterministic ones; observed data stays fixed). The collected variables are the\n# model parameters plus generated quantities, the same columns a posterior fit\n# produces through gen_chains.\nfunction sample_bugs_prior(model, draws, chains, rng)\n    model = base_bugs(model)\n    APPL = JuliaBUGS.AbstractPPL\n    vars = vcat(JuliaBUGS.model_parameters(model), JuliaBUGS.generated_quantities(model))\n    isempty(vars) && error("the model has no parameters or generated quantities to sample")\n    grab(env, vn) = (v = APPL.getvalue(env, vn); v isa AbstractArray ? copy(v) : v)\n    columns = Dict(vn => Vector{Any}(undef, draws * chains) for vn in vars)\n    for c in 1:chains, i in 1:draws\n        env, _ = APPL.evaluate!!(rng, model)\n        for vn in vars\n            columns[vn][i + (c - 1) * draws] = grab(env, vn)\n        end\n    end\n    dict = Dict{FlexiChains.ParameterOrExtra{<:VarName},Array}(\n        FlexiChains.Parameter(vn) =>\n            [columns[vn][i + (c - 1) * draws] for i in 1:draws, c in 1:chains] for vn in vars\n    )\n    return FlexiChains.FlexiChain{VarName}(draws, chains, dict)\nend\n\n# The JuliaBUGS counterpart to draw_streamer. A JuliaBUGS transition carries an\n# unconstrained parameter vector (or, for the environment-based samplers, an\n# evaluation environment), so (unlike the Turing path) draws cannot be read off it\n# directly: the generated quantities and any marginalized discrete latents are\n# reconstructed only when the draws are laid out. Per batch we therefore build a\n# small FlexiChain through the same bundle_transitions + vnchain_to_wire path the\n# final file uses, so the streamed leaf names match the file exactly, on a copy of\n# the model so reconstruction never perturbs the sampler\'s state. AbstractMCMC\n# passes the 1-based chain index as chain_number; each chain\'s batches carry a\n# per-chain monotonic seq.\nfunction bugs_draw_streamer(\n    model, sampler, draws_per_chain::Int, batch_size::Int; keep = nothing,\n)\n    recon = deepcopy(model)\n    side_rng = StableRNG(0)\n    chain = Ref(-1)\n    seq = Ref(0)\n    transitions = Any[]\n    function emit(iteration)\n        isempty(transitions) && return\n        chn = JuliaBUGS.bundle_transitions(\n            FlexiChains.VNChain, recon, transitions, sampler; rng = side_rng,\n        )\n        wire = vnchain_to_wire(chn; keep)\n        nIter, total, _ = wire["size"]\n        flat = wire["value_flat"]\n        params = wire["parameters"]\n        cols = Dict(params[p] => [flat[i + (p - 1) * nIter] for i in 1:nIter] for p in 1:total)\n        println(\n            PROGRESS_IO[],\n            JSON.json(\n                Dict(\n                    "mcmcjs" => "draws",\n                    "chain" => chain[],\n                    "seq" => seq[],\n                    "iteration" => iteration,\n                    "draws" => cols,\n                ),\n            ),\n        )\n        flush(PROGRESS_IO[])\n        seq[] += 1\n        empty!(transitions)\n    end\n    return function (_rng, _model, _sampler, transition, _state, iteration; chain_number = 1, _kwargs...)\n        c = Int(chain_number) - 1\n        if c != chain[]\n            chain[] = c\n            seq[] = 0\n            empty!(transitions)\n        end\n        push!(transitions, deepcopy(transition))\n        if length(transitions) >= batch_size || iteration >= draws_per_chain\n            emit(iteration)\n        end\n    end\nend\n\n# JuliaBUGS pointwise log-likelihood: restore each posterior draw into the\n# evaluation environment, recompute the deterministic nodes in topological\n# order, and record logpdf per observed node. Every unobserved stochastic node\n# must be covered by the posterior columns, or log p(y | theta) would not be a\n# function of the draw.\nfunction loglik_bugs(model, posterior)\n    model = base_bugs(model)\n    APPL = JuliaBUGS.AbstractPPL\n    gd = model.graph_evaluation_data\n\n    sz = posterior["size"]\n    nIter, nCols, nChains = Int(sz[1]), Int(sz[2]), Int(sz[3])\n    flat = posterior["value_flat"]\n    col = Dict(n => i for (i, n) in enumerate(posterior["parameters"]))\n    posterior_names = Set(posterior["name_map"]["parameters"])\n    cell(i, p, c) = begin\n        v = flat[i + (p - 1) * nIter + (c - 1) * nIter * nCols]\n        v === nothing ? NaN : Float64(v)\n    end\n\n    restore = Tuple{APPL.VarName,Int}[]\n    for vn in JuliaBUGS.model_parameters(model)\n        leaves = collect(APPL.varname_leaves(vn, APPL.getvalue(model.evaluation_env, vn)))\n        found = count(l -> string(l) in posterior_names, leaves)\n        found == length(leaves) ||\n            error("the posterior samples do not cover $(vn); were they produced by fitting this spec?")\n        append!(restore, [(l, col[string(l)]) for l in leaves])\n    end\n    observed = [\n        (vn, i) for (i, vn) in enumerate(gd.sorted_nodes) if\n        gd.is_stochastic_vals[i] && gd.is_observed_vals[i]\n    ]\n    isempty(observed) && error("the model has no observed variables to compute a log-likelihood for")\n\n    pnames = string.(first.(observed))\n    n = length(pnames)\n    flat_out = Vector{Union{Float64,Nothing}}(undef, nIter * n * nChains)\n    for c in 1:nChains, i in 1:nIter\n        env = model.evaluation_env\n        for (leaf, p) in restore\n            env = JuliaBUGS.BangBang.setindex!!(env, cell(i, p, c), leaf)\n        end\n        for (k, node) in enumerate(gd.sorted_nodes)\n            if !gd.is_stochastic_vals[k]\n                env = JuliaBUGS.BangBang.setindex!!(\n                    env, gd.node_function_vals[k](env, gd.loop_vars_vals[k]), node,\n                )\n            end\n        end\n        for (k, (vn, idx)) in enumerate(observed)\n            dist = gd.node_function_vals[idx](env, gd.loop_vars_vals[idx])\n            v = logpdf(dist, APPL.getvalue(env, vn))\n            flat_out[i + (k - 1) * nIter + (c - 1) * nIter * n] = isfinite(v) ? Float64(v) : nothing\n        end\n    end\n    return Dict(\n        "size" => [nIter, n, nChains],\n        "value_flat" => flat_out,\n        "parameters" => pnames,\n        "name_map" => Dict("parameters" => pnames, "internals" => String[]),\n    )\nend\n\n# JuliaBUGS posterior prediction: condition the (target-blanked) model on the\n# posterior parameter columns, then evaluate!! ancestral-samples the remaining\n# latents once per posterior draw. No sampler or gradient runs.\nfunction predict_bugs(model, posterior, targets, rng)\n    model = base_bugs(model)\n    APPL = JuliaBUGS.AbstractPPL\n    target_syms = Set(Symbol.(targets))\n    is_target(vn) = APPL.getsym(vn) in target_syms\n\n    sz = posterior["size"]\n    nIter, nCols, nChains = Int(sz[1]), Int(sz[2]), Int(sz[3])\n    flat = posterior["value_flat"]\n    col = Dict(n => i for (i, n) in enumerate(posterior["parameters"]))\n    posterior_names = Set(posterior["name_map"]["parameters"])\n    cell(i, p, c) = begin\n        v = flat[i + (p - 1) * nIter + (c - 1) * nIter * nCols]\n        v === nothing ? NaN : Float64(v)\n    end\n\n    # Nodes fully covered by posterior columns are conditioned; anything\n    # uncovered stays latent and is forward-sampled, like Turing.predict.\n    gd = model.graph_evaluation_data\n    conditioned = APPL.VarName[]\n    restore = Tuple{APPL.VarName,Int}[]\n    for (i, vn) in enumerate(gd.sorted_nodes)\n        (gd.is_stochastic_vals[i] && !gd.is_observed_vals[i] && !is_target(vn)) || continue\n        leaves = collect(APPL.varname_leaves(vn, APPL.getvalue(model.evaluation_env, vn)))\n        found = count(l -> string(l) in posterior_names, leaves)\n        if found == length(leaves)\n            push!(conditioned, vn)\n            append!(restore, [(l, col[string(l)]) for l in leaves])\n        elseif found > 0\n            error("the posterior samples cover $(vn) only partially; refit before predicting")\n        end\n    end\n    isempty(conditioned) &&\n        error("the posterior samples share no parameters with the model; were they produced by fitting this spec?")\n    cond = APPL.condition(model, conditioned)\n\n    any(is_target, cond.graph_evaluation_data.sorted_nodes) ||\n        error("no variables predicted; check that [predict].targets name model variables")\n\n    out_leaves = APPL.VarName[]\n    arr = Array{Float64,3}(undef, 0, 0, 0)\n    for c in 1:nChains, i in 1:nIter\n        env = cond.evaluation_env\n        for (leaf, p) in restore\n            env = JuliaBUGS.BangBang.setindex!!(env, cell(i, p, c), leaf)\n        end\n        cond = JuliaBUGS.BangBang.setproperty!!(cond, :evaluation_env, env)\n        drawn, _ = APPL.evaluate!!(rng, cond)\n        if isempty(out_leaves)\n            out_leaves = [\n                l for vn in cond.graph_evaluation_data.sorted_nodes if is_target(vn)\n                for l in APPL.varname_leaves(vn, APPL.getvalue(drawn, vn))\n            ]\n            arr = Array{Float64,3}(undef, nIter, length(out_leaves), nChains)\n        end\n        for (k, leaf) in enumerate(out_leaves)\n            arr[i, k, c] = Float64(APPL.getvalue(drawn, leaf))\n        end\n    end\n\n    pnames = string.(out_leaves)\n    n = length(pnames)\n    flat_out = Vector{Union{Float64,Nothing}}(undef, nIter * n * nChains)\n    for c in 1:nChains, p in 1:n, i in 1:nIter\n        v = arr[i, p, c]\n        flat_out[i + (p - 1) * nIter + (c - 1) * nIter * n] = isfinite(v) ? v : nothing\n    end\n    return Dict(\n        "size" => [nIter, n, nChains],\n        "value_flat" => flat_out,\n        "parameters" => pnames,\n        "name_map" => Dict("parameters" => pnames, "internals" => String[]),\n    )\nend\n\nfunction provenance()\n    packages = Dict{String,String}()\n    for (_, info) in Pkg.dependencies()\n        if info.name in\n           ("Turing", "FlexiChains", "DynamicPPL", "AbstractMCMC", "JuliaBUGS", "AdvancedHMC", "SliceSampling", "ForwardDiff", "Mooncake", "ADTypes") &&\n           info.version !== nothing\n            packages[info.name] = string(info.version)\n        end\n    end\n    manifest = joinpath(dirname(Base.active_project()), "Manifest.toml")\n    return Dict(\n        "julia_version" => string(VERSION),\n        "packages" => packages,\n        "manifest_sha256" => isfile(manifest) ? bytes2hex(sha256(read(manifest))) : "",\n    )\nend\n\n# Resolve the model entry function: use the requested name, falling back to the\n# conventional build_model. This lets a request leave the entry implicit, or name a\n# custom entry that a given model file does not define (then build_model is used).\n# Load the user\'s model file into a throwaway module. Isolation keeps repeated\n# requests in the persistent worker from colliding on names (e.g. two models each\n# defining `const model_def`), and confines the model\'s globals to their own scope.\n# Compiling draws every parameter it is not given from its prior, and a draw from a\n# vague prior such as dgamma(0.001, 0.001) can underflow into a Weibull scale of zero\n# or a Poisson rate of NaN before sampling starts. An entry that takes the starting\n# values as a second argument gets them at compile time.\nfunction build_bugs_model(entry, data, sampler)\n    haskey(sampler, "initial_params") && applicable(entry, data, (;)) || return entry(data)\n    return entry(data, bugs_namedtuple(sampler["initial_params"]))\nend\n\nfunction load_model_module(path)\n    mod = Module(gensym(:UserModel))\n    if endswith(lowercase(path), ".bugs")\n        # A bare BUGS program, parsed as the string form of `@bugs` parses it with\n        # dotted names kept, and given the entry a Julia model file would define.\n        model_def = JuliaBUGS.Parser._bugs_string_input(read(abspath(path), String), false)\n        Core.eval(mod, :(using JuliaBUGS))\n        Core.eval(mod, :(const model_def = $(Meta.quot(model_def))))\n        Core.eval(\n            mod, :(build_model(data, inits = (;)) = JuliaBUGS.compile(model_def, data, inits)),\n        )\n    else\n        Base.include(mod, abspath(path))\n    end\n    return mod\nend\n\nfunction resolve_entry(mod, requested)\n    for name in (requested, "build_model")\n        name === nothing && continue\n        sym = Symbol(name)\n        # The model was just include\'d, so its bindings live in a newer world than\n        # this frame; resolve them in the latest world to avoid a Julia 1.12\n        # world-age warning on the access.\n        Base.invokelatest(isdefined, mod, sym) && return Base.invokelatest(getfield, mod, sym)\n    end\n    error("model file defines no entry function (looked for $(requested) and build_model)")\nend\n\n# Runs one request end to end. Returns {"ok": true, "provenance": ...} or\n# {"ok": false, "error": ..., "stage": ...}; never throws.\nfunction handle_request(request)\n    out = request["out"]\n    mode = get(request, "mode", "fit")\n    backend = get(get(request, "backend", Dict()), "id", "turing")\n    stage = "compile"\n    try\n        Random.seed!(Int(request["seed"]))\n        rng = StableRNG(Int(request["seed"]))\n        modelmod = load_model_module(request["model"]["file"])\n        entry = resolve_entry(modelmod, get(request["model"], "entry", nothing))\n\n        wire = if mode == "loglik"\n            if backend == "juliabugs"\n                model = Base.invokelatest(entry, bugs_namedtuple(request["data"]))\n                stage = "load_samples"\n                posterior = JSON.parsefile(request["samples"])\n                stage = "loglik"\n                Base.invokelatest(loglik_bugs, model, posterior)\n            else\n                data = ModelData(to_namedtuple(request["data"]))\n                model = Base.invokelatest(entry, data)\n                model = Base.invokelatest(condition_on_data, model, data)\n                stage = "load_samples"\n                chn = wire_to_vnchain(JSON.parsefile(request["samples"]), String[])\n                stage = "loglik"\n                pll = Base.invokelatest(Turing.DynamicPPL.pointwise_loglikelihoods, model, chn)\n                isempty(FlexiChains.parameters(pll)) &&\n                    error("the model has no observed variables to compute a log-likelihood for")\n                vnchain_to_wire(pll)\n            end\n        elseif mode == "predict"\n            if backend == "juliabugs"\n                model = Base.invokelatest(entry, bugs_namedtuple(request["data"]))\n                stage = "load_samples"\n                posterior = JSON.parsefile(request["samples"])\n                stage = "predict"\n                Base.invokelatest(predict_bugs, model, posterior, request["predict"]["targets"], rng)\n            else\n                model = Base.invokelatest(entry, ModelData(to_namedtuple(request["data"])))\n                stage = "load_samples"\n                rchn = wire_to_vnchain(JSON.parsefile(request["samples"]), request["predict"]["targets"])\n                stage = "predict"\n                pp = Base.invokelatest(predict, rng, model, rchn; include_all = false)\n                isempty(FlexiChains.parameters(pp)) &&\n                    error("no variables predicted; check that [predict].targets name unconditioned outcomes")\n                vnchain_to_wire(pp)\n            end\n        else\n            data = backend == "juliabugs" ? bugs_namedtuple(request["data"]) : ModelData(to_namedtuple(request["data"]))\n            parallel = get(request["sampler"], "parallel", "serial")\n            chains = Int(get(request["sampler"], "chains", 4))\n            if parallel == "distributed" && backend != "juliabugs"\n                # Every process needs the model\'s definitions under the same\n                # names; the module-per-request isolation gives way to Main.\n                stage = "distribute"\n                Base.invokelatest(setup_distributed, chains, request["model"]["file"])\n                modelmod = Main\n                entry = resolve_entry(Main, get(request["model"], "entry", nothing))\n            end\n            sampler_conf = apply_model_defaults(request["sampler"], modelmod)\n            draws = Int(request["sampler"]["draws"])\n            stage = "sample"\n            if backend == "juliabugs"\n                stage = "compile"\n                model = Base.invokelatest(build_bugs_model, entry, data, sampler_conf)\n                stage = "sample"\n                chn = if get(sampler_conf, "algorithm", "NUTS") == "Prior"\n                    Base.invokelatest(sample_bugs_prior, model, draws, chains, rng)\n                else\n                    model = Base.invokelatest(\n                        prepare_bugs_model, model, sampler_conf,\n                        get(request["model"], "evaluation_mode", nothing),\n                    )\n                    sampler = Base.invokelatest(build_bugs_sampler, sampler_conf, model)\n                    warmup = Int(get(sampler_conf, "warmup", 1000))\n                    threads = parallel == "threads"\n                    # Reconstruction reads the plain BUGSModel; a gradient sampler runs wrapped.\n                    cb = get(request, "stream_draws", false) && !threads ?\n                        bugs_draw_streamer(\n                            base_bugs(model), sampler, draws,\n                            Int(get(request, "draw_batch_size", 25));\n                            keep = bugs_column_filter(request, model),\n                        ) : nothing\n                    Base.invokelatest(\n                        sample_bugs, model, sampler, warmup, draws, chains, rng;\n                        callback = cb, thin = Int(get(request["sampler"], "thin", 1)), threads,\n                        initial_params = Base.invokelatest(\n                            bugs_initial_params, model, sampler_conf,\n                        ),\n                    )\n                end\n                vnchain_to_wire(chn; keep = bugs_column_filter(request, model))\n            else\n                sampler, warmup = build_sampler(sampler_conf, modelmod)\n                # The draw streamer assumes chains arrive one at a time; with\n                # concurrent chains the caller must not request streaming.\n                cb = get(request, "stream_draws", false) && parallel == "serial" ?\n                    draw_streamer(draws, Int(get(request, "draw_batch_size", 25))) : nothing\n                extra = sampling_kwargs(request["sampler"], warmup, chains)\n                chn = Base.invokelatest(\n                    build_and_sample, entry, data, sampler, draws, chains, rng;\n                    callback = cb, extra, parallel,\n                )\n                vnchain_to_wire(chn)\n            end\n        end\n\n        stage = "write"\n        tmp = out * ".tmp"\n        open(tmp, "w") do io\n            JSON.print(io, wire)\n        end\n        mv(tmp, out; force = true)\n\n        return Dict("ok" => true, "provenance" => provenance())\n    catch err\n        return Dict("ok" => false, "error" => sprint(showerror, err), "stage" => stage)\n    end\nend\n',
   "julia-env/Project.toml": '[deps]\nAdvancedHMC = "0bf59076-c3b1-5ca4-86bd-e02cd72cde3d"\nDimensionalData = "0703355e-b756-11e9-17c0-8b28908087d0"\nFlexiChains = "4a37a8b9-6e57-4b92-8664-298d46e639f7"\nForwardDiff = "f6369f11-7733-5829-9624-2563aa707210"\nJSON = "682c06a0-de6a-54ab-a142-c8b1cf79cde6"\nJuliaBUGS = "ba9fb4c0-828e-4473-b6a1-cd2560fee5bf"\nMooncake = "da2b9cff-9c12-43a0-ae48-6db2b0edb7d6"\nReverseDiff = "37e2e3b7-166d-5795-8a7a-e32c996b4267"\nSliceSampling = "43f4d3e8-9711-4a8c-bd1b-03ac73a255cf"\nStableRNGs = "860ef19b-820b-49d6-a774-d7a799459cd3"\nStatsFuns = "4c63d2b9-4356-54db-8cca-17b64c39e42c"\nTuring = "fce5fe82-541a-59a6-adf8-730c64b5f9a0"\n',
   "julia-env/Manifest.toml": '# This file is machine-generated - editing it directly is not advised\n\njulia_version = "1.12.7"\nmanifest_format = "2.0"\nproject_hash = "ea3a76551fb06c81495151e9f5037ca1e9513b81"\n\n[[deps.ADTypes]]\ngit-tree-sha1 = "5970c86505ae9c07bf5bc521ef2bbbb3849e8b7b"\nuuid = "47edcb42-4c32-4615-8424-f2b9edc5f35b"\nversion = "1.23.0"\n\n    [deps.ADTypes.extensions]\n    ADTypesChainRulesCoreExt = "ChainRulesCore"\n    ADTypesConstructionBaseExt = "ConstructionBase"\n    ADTypesEnzymeCoreExt = "EnzymeCore"\n\n    [deps.ADTypes.weakdeps]\n    ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4"\n    ConstructionBase = "187b0558-2788-49d3-abe0-74a17ed4e7c9"\n    EnzymeCore = "f151be2c-9106-41f4-ab19-57ee4f262869"\n\n[[deps.ANSIColoredPrinters]]\ngit-tree-sha1 = "574baf8110975760d391c710b6341da1afa48d8c"\nuuid = "a4c015fc-c6ff-483c-b24f-f7ea428134e9"\nversion = "0.0.1"\n\n[[deps.AbstractFFTs]]\ndeps = ["LinearAlgebra"]\ngit-tree-sha1 = "d92ad398961a3ed262d8bf04a1a2b8340f915fef"\nuuid = "621f4979-c628-5d54-868e-fcf4e3e8185c"\nversion = "1.5.0"\nweakdeps = ["ChainRulesCore", "Test"]\n\n    [deps.AbstractFFTs.extensions]\n    AbstractFFTsChainRulesCoreExt = "ChainRulesCore"\n    AbstractFFTsTestExt = "Test"\n\n[[deps.AbstractMCMC]]\ndeps = ["BangBang", "ConsoleProgressMonitor", "Dates", "Distributed", "LogDensityProblems", "Logging", "LoggingExtras", "ProgressLogging", "Random", "StatsBase", "TerminalLoggers", "UUIDs"]\ngit-tree-sha1 = "328c7d50f307c66308a915abb20d9889e5aab48b"\nuuid = "80f14c24-f653-4e6a-9b94-39d6b0f70001"\nversion = "5.16.0"\n\n    [deps.AbstractMCMC.extensions]\n    AbstractMCMCOnlineStatsExt = "OnlineStats"\n    AbstractMCMCTensorBoardLoggerExt = "TensorBoardLogger"\n\n    [deps.AbstractMCMC.weakdeps]\n    OnlineStats = "a15396b6-48d5-5d58-9928-6d29437db91e"\n    TensorBoardLogger = "899adc3e-224a-11e9-021f-63837185c80f"\n\n[[deps.AbstractPPL]]\ndeps = ["ADTypes", "AbstractMCMC", "Accessors", "BangBang", "DensityInterface", "JSON", "LinearAlgebra", "MacroTools", "OrderedCollections", "Random", "StatsBase"]\ngit-tree-sha1 = "31fb177c9952267ac2dc54a44868cb768390e6ef"\nuuid = "7a57a42e-76ec-4ea3-a279-07e840d6d9cf"\nversion = "0.15.5"\nweakdeps = ["DiffResults", "DifferentiationInterface", "Distributions", "ForwardDiff", "Mooncake", "Test"]\n\n    [deps.AbstractPPL.extensions]\n    AbstractPPLDifferentiationInterfaceExt = ["DifferentiationInterface"]\n    AbstractPPLDistributionsExt = ["Distributions", "LinearAlgebra"]\n    AbstractPPLForwardDiffExt = ["ForwardDiff", "DiffResults"]\n    AbstractPPLMooncakeExt = ["Mooncake"]\n    AbstractPPLTestExt = ["Test"]\n\n[[deps.AbstractTrees]]\ngit-tree-sha1 = "2d9c9a55f9c93e8887ad391fbae72f8ef55e1177"\nuuid = "1520ce14-60c1-5f80-bbc7-55ef81b5835c"\nversion = "0.4.5"\n\n[[deps.Accessors]]\ndeps = ["CompositionsBase", "ConstructionBase", "Dates", "InverseFunctions", "MacroTools"]\ngit-tree-sha1 = "7063ad1083578215c7c4bf410368150abe8d5524"\nuuid = "7d9f7c33-5ae7-4f3b-8dc6-eff91059b697"\nversion = "0.1.45"\n\n    [deps.Accessors.extensions]\n    AxisKeysExt = "AxisKeys"\n    IntervalSetsExt = "IntervalSets"\n    LinearAlgebraExt = "LinearAlgebra"\n    StaticArraysExt = "StaticArrays"\n    StructArraysExt = "StructArrays"\n    TestExt = "Test"\n    UnitfulExt = "Unitful"\n\n    [deps.Accessors.weakdeps]\n    AxisKeys = "94b1ba4f-4ee9-5380-92f1-94cde586c3c5"\n    IntervalSets = "8197267c-284f-5f27-9208-e0e47529a953"\n    LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"\n    StaticArrays = "90137ffa-7385-5640-81b9-e52037218182"\n    StructArrays = "09ab397b-f2b6-538f-b94a-2f83cf4a842a"\n    Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"\n    Unitful = "1986cc42-f94f-5a68-af5c-568840ba703d"\n\n[[deps.Adapt]]\ndeps = ["LinearAlgebra"]\ngit-tree-sha1 = "daa72978cd7a624246e894a4f4f067706d4e17e2"\nuuid = "79e6a3ab-5dfb-504d-930d-738a2a938a0e"\nversion = "4.7.0"\nweakdeps = ["SparseArrays", "StaticArrays"]\n\n    [deps.Adapt.extensions]\n    AdaptSparseArraysExt = "SparseArrays"\n    AdaptStaticArraysExt = "StaticArrays"\n\n[[deps.AdvancedHMC]]\ndeps = ["AbstractMCMC", "ArgCheck", "DocStringExtensions", "IrrationalConstants", "LinearAlgebra", "LogDensityProblems", "LogDensityProblemsAD", "LogExpFunctions", "ProgressMeter", "Random", "Setfield", "Statistics", "StatsBase"]\ngit-tree-sha1 = "3a188c0f280dd237a03b29b2d9023859ef85a429"\nuuid = "0bf59076-c3b1-5ca4-86bd-e02cd72cde3d"\nversion = "0.8.5"\n\n    [deps.AdvancedHMC.extensions]\n    AdvancedHMCADTypesExt = "ADTypes"\n    AdvancedHMCCUDAExt = "CUDA"\n    AdvancedHMCComponentArraysExt = "ComponentArrays"\n    AdvancedHMCMCMCChainsExt = "MCMCChains"\n    AdvancedHMCOrdinaryDiffEqSymplecticRKExt = "OrdinaryDiffEqSymplecticRK"\n\n    [deps.AdvancedHMC.weakdeps]\n    ADTypes = "47edcb42-4c32-4615-8424-f2b9edc5f35b"\n    CUDA = "052768ef-5323-5732-b1bb-66c8b64840ba"\n    ComponentArrays = "b0b7db55-cfe3-40fc-9ded-d10e2dbeff66"\n    MCMCChains = "c7f686f2-ff18-58e9-bc7b-31028e88f75d"\n    OrdinaryDiffEqSymplecticRK = "fa646aed-7ef9-47eb-84c4-9443fc8cbfa8"\n\n[[deps.AdvancedMH]]\ndeps = ["AbstractMCMC", "Distributions", "DocStringExtensions", "FillArrays", "LinearAlgebra", "LogDensityProblems", "Random", "Requires"]\ngit-tree-sha1 = "62ddbccf0ce5c26f8ef3cebe4bedef6b1599d616"\nuuid = "5b7e9947-ddc0-4b3f-9b55-0d8042f74170"\nversion = "0.8.10"\n\n    [deps.AdvancedMH.extensions]\n    AdvancedMHForwardDiffExt = ["DiffResults", "ForwardDiff"]\n    AdvancedMHMCMCChainsExt = "MCMCChains"\n    AdvancedMHStructArraysExt = "StructArrays"\n\n    [deps.AdvancedMH.weakdeps]\n    DiffResults = "163ba53b-c6d8-5494-b064-1a9d43ac40c5"\n    ForwardDiff = "f6369f11-7733-5829-9624-2563aa707210"\n    MCMCChains = "c7f686f2-ff18-58e9-bc7b-31028e88f75d"\n    StructArrays = "09ab397b-f2b6-538f-b94a-2f83cf4a842a"\n\n[[deps.AdvancedPS]]\ndeps = ["AbstractMCMC", "Distributions", "Random", "Random123", "Requires", "SSMProblems", "StatsFuns"]\ngit-tree-sha1 = "d92dd3fb4cc2748860ae8d5dd1d324cf0715a53b"\nuuid = "576499cb-2369-40b2-a588-c64705576edc"\nversion = "0.7.2"\nweakdeps = ["Libtask"]\n\n    [deps.AdvancedPS.extensions]\n    AdvancedPSLibtaskExt = "Libtask"\n\n[[deps.AdvancedVI]]\ndeps = ["ADTypes", "AbstractPPL", "Accessors", "ChainRulesCore", "DiffResults", "Distributions", "DocStringExtensions", "FillArrays", "Functors", "LinearAlgebra", "LogDensityProblems", "Optimisers", "ProgressMeter", "Random", "StatsBase"]\ngit-tree-sha1 = "fc42c29943eae508fd28ec620d1faa4d2c1ce044"\nuuid = "b5ca4192-6429-45e5-a2d9-87aec30a685c"\nversion = "0.7.0"\n\n    [deps.AdvancedVI.extensions]\n    AdvancedVIDynamicPPLExt = ["DynamicPPL", "Accessors", "Distributions", "LogDensityProblems"]\n    AdvancedVIEnzymeExt = ["Enzyme", "ChainRulesCore"]\n    AdvancedVIMooncakeExt = ["Mooncake", "ChainRulesCore"]\n    AdvancedVIReverseDiffExt = ["ReverseDiff", "ChainRulesCore"]\n\n    [deps.AdvancedVI.weakdeps]\n    DynamicPPL = "366bfd00-2699-11ea-058f-f148b4cae6d8"\n    Enzyme = "7da242da-08ed-463a-9acd-ee780be4f1d9"\n    Mooncake = "da2b9cff-9c12-43a0-ae48-6db2b0edb7d6"\n    ReverseDiff = "37e2e3b7-166d-5795-8a7a-e32c996b4267"\n\n[[deps.AliasTables]]\ndeps = ["PtrArrays", "Random"]\ngit-tree-sha1 = "9876e1e164b144ca45e9e3198d0b689cadfed9ff"\nuuid = "66dad0bd-aa9a-41b7-9441-69ab47430ed8"\nversion = "1.1.3"\n\n[[deps.ArgCheck]]\ngit-tree-sha1 = "f9e9a66c9b7be1ad7372bbd9b062d9230c30c5ce"\nuuid = "dce04be8-c92d-5529-be00-80e4d2c0e197"\nversion = "2.5.0"\n\n[[deps.ArgTools]]\nuuid = "0dad84c5-d112-42e6-8d28-ef12dabb789f"\nversion = "1.1.2"\n\n[[deps.ArnoldiMethod]]\ndeps = ["LinearAlgebra", "Random", "StaticArrays"]\ngit-tree-sha1 = "d57bd3762d308bded22c3b82d033bff85f6195c6"\nuuid = "ec485272-7323-5ecc-a04f-4719b315124d"\nversion = "0.4.0"\n\n[[deps.ArrayInterface]]\ndeps = ["Adapt", "LinearAlgebra"]\ngit-tree-sha1 = "13f3b228c230ef0b4ecafd73c8ca9e99987ca692"\nuuid = "4fba245c-0d91-5ea0-9b3e-6abc04ee57a9"\nversion = "7.30.0"\n\n    [deps.ArrayInterface.extensions]\n    ArrayInterfaceAMDGPUExt = "AMDGPU"\n    ArrayInterfaceBandedMatricesExt = "BandedMatrices"\n    ArrayInterfaceBlockBandedMatricesExt = "BlockBandedMatrices"\n    ArrayInterfaceCUDAExt = "CUDA"\n    ArrayInterfaceCUDSSExt = ["CUDSS", "CUDA"]\n    ArrayInterfaceChainRulesCoreExt = "ChainRulesCore"\n    ArrayInterfaceChainRulesExt = "ChainRules"\n    ArrayInterfaceFillArraysExt = "FillArrays"\n    ArrayInterfaceGPUArraysCoreExt = "GPUArraysCore"\n    ArrayInterfaceMetalExt = "Metal"\n    ArrayInterfaceReverseDiffExt = "ReverseDiff"\n    ArrayInterfaceSparseArraysExt = "SparseArrays"\n    ArrayInterfaceStaticArraysCoreExt = "StaticArraysCore"\n    ArrayInterfaceTrackerExt = "Tracker"\n\n    [deps.ArrayInterface.weakdeps]\n    AMDGPU = "21141c5a-9bdb-4563-92ae-f87d6854732e"\n    BandedMatrices = "aae01518-5342-5314-be14-df237901396f"\n    BlockBandedMatrices = "ffab5731-97b5-5995-9138-79e8c1846df0"\n    CUDA = "052768ef-5323-5732-b1bb-66c8b64840ba"\n    CUDSS = "45b445bb-4962-46a0-9369-b4df9d0f772e"\n    ChainRules = "082447d4-558c-5d27-93f4-14fc19e9eca2"\n    ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4"\n    FillArrays = "1a297f60-69ca-5386-bcde-b61e274b549b"\n    GPUArraysCore = "46192b85-c4d5-4398-a991-12ede77f4527"\n    Metal = "dde4c033-4e86-420c-a63e-0dd931031962"\n    ReverseDiff = "37e2e3b7-166d-5795-8a7a-e32c996b4267"\n    SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf"\n    StaticArraysCore = "1e83bf80-4336-4d27-bf5d-d5a4f845583c"\n    Tracker = "9f7883ad-71c0-57eb-9f7f-b5c9e6d3789c"\n\n[[deps.Artifacts]]\nuuid = "56f22d72-fd6d-98f1-02f0-08ddc0907c33"\nversion = "1.11.0"\n\n[[deps.BangBang]]\ndeps = ["Accessors", "ConstructionBase", "InitialValues", "LinearAlgebra"]\ngit-tree-sha1 = "cceb62468025be98d42a5dc581b163c20896b040"\nuuid = "198e06fe-97b7-11e9-32a5-e1d131e6ad66"\nversion = "0.4.9"\n\n    [deps.BangBang.extensions]\n    BangBangChainRulesCoreExt = "ChainRulesCore"\n    BangBangDataFramesExt = "DataFrames"\n    BangBangStaticArraysExt = "StaticArrays"\n    BangBangStructArraysExt = "StructArrays"\n    BangBangTablesExt = "Tables"\n    BangBangTypedTablesExt = "TypedTables"\n\n    [deps.BangBang.weakdeps]\n    ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4"\n    DataFrames = "a93c6f00-e57d-5684-b7b6-d8193f3e46c0"\n    StaticArrays = "90137ffa-7385-5640-81b9-e52037218182"\n    StructArrays = "09ab397b-f2b6-538f-b94a-2f83cf4a842a"\n    Tables = "bd369af6-aec1-5ad0-b16a-f7cc5008161c"\n    TypedTables = "9d95f2ec-7b3d-5a63-8d20-e2491e220bb9"\n\n[[deps.Base64]]\nuuid = "2a0f44e3-6c83-55bd-87e4-b1978d98bd5f"\nversion = "1.11.0"\n\n[[deps.Bijectors]]\ndeps = ["ADTypes", "AbstractPPL", "ArgCheck", "ChangesOfVariables", "Distributions", "DocStringExtensions", "FillArrays", "Functors", "InverseFunctions", "IrrationalConstants", "LinearAlgebra", "LogExpFunctions", "MappedArrays", "Random", "Reexport", "Roots", "SparseArrays", "Statistics", "Test"]\ngit-tree-sha1 = "1eddcf2576939a8990350c1d23eb51a14752b7b9"\nuuid = "76274a88-744f-5084-9051-94815aaf08c4"\nversion = "0.16.2"\n\n    [deps.Bijectors.extensions]\n    BijectorsChainRulesCoreExt = "ChainRulesCore"\n    BijectorsEnzymeCoreExt = "EnzymeCore"\n    BijectorsForwardDiffExt = "ForwardDiff"\n    BijectorsLazyArraysExt = "LazyArrays"\n    BijectorsMooncakeExt = "Mooncake"\n    BijectorsReverseDiffChainRulesExt = ["ChainRules", "ReverseDiff"]\n    BijectorsReverseDiffExt = "ReverseDiff"\n\n    [deps.Bijectors.weakdeps]\n    ChainRules = "082447d4-558c-5d27-93f4-14fc19e9eca2"\n    ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4"\n    EnzymeCore = "f151be2c-9106-41f4-ab19-57ee4f262869"\n    ForwardDiff = "f6369f11-7733-5829-9624-2563aa707210"\n    LazyArrays = "5078a376-72f3-5289-bfd5-ec5146d43c02"\n    Mooncake = "da2b9cff-9c12-43a0-ae48-6db2b0edb7d6"\n    ReverseDiff = "37e2e3b7-166d-5795-8a7a-e32c996b4267"\n\n[[deps.ChainRulesCore]]\ndeps = ["Compat", "LinearAlgebra"]\ngit-tree-sha1 = "12177ad6b3cad7fd50c8b3825ce24a99ad61c18f"\nuuid = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4"\nversion = "1.26.1"\nweakdeps = ["SparseArrays"]\n\n    [deps.ChainRulesCore.extensions]\n    ChainRulesCoreSparseArraysExt = "SparseArrays"\n\n[[deps.Chairmarks]]\ndeps = ["Printf", "Random"]\ngit-tree-sha1 = "9a49491e67e7a4d6f885c43d00bb101e6e5a434b"\nuuid = "0ca39b1e-fe0b-4e98-acfc-b1656634c4de"\nversion = "1.3.1"\nweakdeps = ["Statistics"]\n\n    [deps.Chairmarks.extensions]\n    StatisticsChairmarksExt = ["Statistics"]\n\n[[deps.ChangesOfVariables]]\ndeps = ["LinearAlgebra"]\ngit-tree-sha1 = "83ee8183bd8c4a390ae178385e6c7b3aa4e468b2"\nuuid = "9e997f8a-9a97-42d5-a9f1-ce6bfc15e2c0"\nversion = "0.1.11"\nweakdeps = ["InverseFunctions", "Test"]\n\n    [deps.ChangesOfVariables.extensions]\n    ChangesOfVariablesInverseFunctionsExt = "InverseFunctions"\n    ChangesOfVariablesTestExt = "Test"\n\n[[deps.CodecZlib]]\ndeps = ["TranscodingStreams", "Zlib_jll"]\ngit-tree-sha1 = "970758a3d591a2a5c2a907c53f2e2f8c1b1d3537"\nuuid = "944b1d66-785c-5afd-91f1-9de20f533193"\nversion = "0.7.9"\n\n[[deps.CommonSolve]]\ngit-tree-sha1 = "cf963add2340ad9960e5eb22844e61ad8f931fe1"\nuuid = "38540f10-b2f7-11e9-35d8-d573e4eb0ff2"\nversion = "0.2.13"\n\n[[deps.CommonSubexpressions]]\ndeps = ["MacroTools"]\ngit-tree-sha1 = "cda2cfaebb4be89c9084adaca7dd7333369715c5"\nuuid = "bbf7d656-a473-5ed7-a52c-81e309532950"\nversion = "0.3.1"\n\n[[deps.Compat]]\ndeps = ["TOML", "UUIDs"]\ngit-tree-sha1 = "9d8a54ce4b17aa5bdce0ea5c34bc5e7c340d16ad"\nuuid = "34da2185-b29b-5c13-b0c7-acf172513d20"\nversion = "4.18.1"\nweakdeps = ["Dates", "LinearAlgebra"]\n\n    [deps.Compat.extensions]\n    CompatLinearAlgebraExt = "LinearAlgebra"\n\n[[deps.CompilerSupportLibraries_jll]]\ndeps = ["Artifacts", "Libdl"]\nuuid = "e66e0078-7015-5450-92f7-15fbd957f2ae"\nversion = "1.3.1+2"\n\n[[deps.CompositionsBase]]\ngit-tree-sha1 = "802bb88cd69dfd1509f6670416bd4434015693ad"\nuuid = "a33af91c-f02d-484b-be07-31d278c5ca2b"\nversion = "0.1.2"\nweakdeps = ["InverseFunctions"]\n\n    [deps.CompositionsBase.extensions]\n    CompositionsBaseInverseFunctionsExt = "InverseFunctions"\n\n[[deps.ConsoleProgressMonitor]]\ndeps = ["Logging", "ProgressMeter"]\ngit-tree-sha1 = "3ab7b2136722890b9af903859afcf457fa3059e8"\nuuid = "88cd18e8-d9cc-4ea6-8889-5259c0d15c8b"\nversion = "0.1.2"\n\n[[deps.ConstructionBase]]\ngit-tree-sha1 = "b4b092499347b18a015186eae3042f72267106cb"\nuuid = "187b0558-2788-49d3-abe0-74a17ed4e7c9"\nversion = "1.6.0"\nweakdeps = ["IntervalSets", "LinearAlgebra", "StaticArrays"]\n\n    [deps.ConstructionBase.extensions]\n    ConstructionBaseIntervalSetsExt = "IntervalSets"\n    ConstructionBaseLinearAlgebraExt = "LinearAlgebra"\n    ConstructionBaseStaticArraysExt = "StaticArrays"\n\n[[deps.DataAPI]]\ngit-tree-sha1 = "abe83f3a2f1b857aac70ef8b269080af17764bbe"\nuuid = "9a962f9c-6df0-11e9-0e5d-c546b8b5ee8a"\nversion = "1.16.0"\n\n[[deps.DataStructures]]\ndeps = ["OrderedCollections"]\ngit-tree-sha1 = "b0bc6d2cad1fed8b7fd59a1551a991cb3d2809e6"\nuuid = "864edb3b-99cc-5e75-8d2d-829cb0a9cfe8"\nversion = "0.19.6"\n\n[[deps.DataValueInterfaces]]\ngit-tree-sha1 = "bfc1187b79289637fa0ef6d4436ebdfe6905cbd6"\nuuid = "e2d170a0-9d28-54be-80f0-106bbe20a464"\nversion = "1.0.0"\n\n[[deps.Dates]]\ndeps = ["Printf"]\nuuid = "ade2ca70-3891-5945-98fb-dc099432e06a"\nversion = "1.11.0"\n\n[[deps.DelimitedFiles]]\ndeps = ["Mmap"]\ngit-tree-sha1 = "9e2f36d3c96a820c678f2f1f1782582fcf685bae"\nuuid = "8bb1440f-4735-579b-a4ab-409b98df4dab"\nversion = "1.9.1"\n\n[[deps.DensityInterface]]\ndeps = ["InverseFunctions", "Test"]\ngit-tree-sha1 = "80c3e8639e3353e5d2912fb3a1916b8455e2494b"\nuuid = "b429d917-457f-4dbc-8f4c-0cc954292b1d"\nversion = "0.4.0"\n\n[[deps.DiffResults]]\ndeps = ["StaticArraysCore"]\ngit-tree-sha1 = "782dd5f4561f5d267313f23853baaaa4c52ea621"\nuuid = "163ba53b-c6d8-5494-b064-1a9d43ac40c5"\nversion = "1.1.0"\n\n[[deps.DiffRules]]\ndeps = ["IrrationalConstants", "LogExpFunctions", "NaNMath", "Random", "SpecialFunctions"]\ngit-tree-sha1 = "79a2aca180a85c690c58a020d47b426954b590f8"\nuuid = "b552c78f-8df3-52c6-915a-8e097449b14b"\nversion = "1.16.0"\n\n[[deps.DifferentiationInterface]]\ndeps = ["ADTypes", "LinearAlgebra"]\ngit-tree-sha1 = "0693d8b0a4608ff289d228ab4c598df5894845cd"\nuuid = "a0c0ee7d-e4b9-4e03-894e-1c5f64a51d63"\nversion = "0.7.21"\n\n    [deps.DifferentiationInterface.extensions]\n    DifferentiationInterfaceChainRulesCoreExt = "ChainRulesCore"\n    DifferentiationInterfaceDiffractorExt = "Diffractor"\n    DifferentiationInterfaceEnzymeExt = ["EnzymeCore", "Enzyme"]\n    DifferentiationInterfaceFastDifferentiationExt = "FastDifferentiation"\n    DifferentiationInterfaceFiniteDiffExt = "FiniteDiff"\n    DifferentiationInterfaceFiniteDifferencesExt = "FiniteDifferences"\n    DifferentiationInterfaceForwardDiffExt = ["ForwardDiff", "DiffResults"]\n    DifferentiationInterfaceGPUArraysCoreExt = ["GPUArraysCore", "Adapt"]\n    DifferentiationInterfaceGTPSAExt = "GTPSA"\n    DifferentiationInterfaceHyperHessiansExt = "HyperHessians"\n    DifferentiationInterfaceMooncakeExt = "Mooncake"\n    DifferentiationInterfacePolyesterForwardDiffExt = ["PolyesterForwardDiff", "ForwardDiff", "DiffResults"]\n    DifferentiationInterfaceReverseDiffExt = ["ReverseDiff", "DiffResults"]\n    DifferentiationInterfaceSparseArraysExt = "SparseArrays"\n    DifferentiationInterfaceSparseConnectivityTracerExt = "SparseConnectivityTracer"\n    DifferentiationInterfaceSparseMatrixColoringsExt = "SparseMatrixColorings"\n    DifferentiationInterfaceStaticArraysExt = "StaticArrays"\n    DifferentiationInterfaceSymbolicsExt = "Symbolics"\n    DifferentiationInterfaceTrackerExt = "Tracker"\n    DifferentiationInterfaceZygoteExt = ["Zygote", "ForwardDiff"]\n\n    [deps.DifferentiationInterface.weakdeps]\n    Adapt = "79e6a3ab-5dfb-504d-930d-738a2a938a0e"\n    ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4"\n    DiffResults = "163ba53b-c6d8-5494-b064-1a9d43ac40c5"\n    Diffractor = "9f5e2b26-1114-432f-b630-d3fe2085c51c"\n    Enzyme = "7da242da-08ed-463a-9acd-ee780be4f1d9"\n    EnzymeCore = "f151be2c-9106-41f4-ab19-57ee4f262869"\n    FastDifferentiation = "eb9bf01b-bf85-4b60-bf87-ee5de06c00be"\n    FiniteDiff = "6a86dc24-6348-571c-b903-95158fe2bd41"\n    FiniteDifferences = "26cc04aa-876d-5657-8c51-4c34ba976000"\n    ForwardDiff = "f6369f11-7733-5829-9624-2563aa707210"\n    GPUArraysCore = "46192b85-c4d5-4398-a991-12ede77f4527"\n    GTPSA = "b27dd330-f138-47c5-815b-40db9dd9b6e8"\n    HyperHessians = "06b494a0-c8e0-40cc-ad32-d99506a00a6c"\n    Mooncake = "da2b9cff-9c12-43a0-ae48-6db2b0edb7d6"\n    PolyesterForwardDiff = "98d1487c-24ca-40b6-b7ab-df2af84e126b"\n    ReverseDiff = "37e2e3b7-166d-5795-8a7a-e32c996b4267"\n    SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf"\n    SparseConnectivityTracer = "9f842d2f-2579-4b1d-911e-f412cf18a3f5"\n    SparseMatrixColorings = "0a514795-09f3-496d-8182-132a7b665d35"\n    StaticArrays = "90137ffa-7385-5640-81b9-e52037218182"\n    Symbolics = "0c5d862f-8b57-4792-8d23-62f2024744c7"\n    Tracker = "9f7883ad-71c0-57eb-9f7f-b5c9e6d3789c"\n    Zygote = "e88e6eb3-aa80-5325-afca-941959d7151f"\n\n[[deps.DimensionalData]]\ndeps = ["ConstructionBase", "DataAPI", "Dates", "Extents", "Interfaces", "IntervalSets", "InvertedIndices", "IteratorInterfaceExtensions", "LinearAlgebra", "OrderedCollections", "PrecompileTools", "Random", "Statistics", "TableTraits", "Tables"]\ngit-tree-sha1 = "57bbee194533adaa755b5cae528eabdea5d05039"\nuuid = "0703355e-b756-11e9-17c0-8b28908087d0"\nversion = "0.30.1"\n\n    [deps.DimensionalData.extensions]\n    DimensionalDataAbstractFFTsExt = "AbstractFFTs"\n    DimensionalDataAdaptExt = "Adapt"\n    DimensionalDataAlgebraOfGraphicsExt = "AlgebraOfGraphics"\n    DimensionalDataArrayInterfaceExt = "ArrayInterface"\n    DimensionalDataCategoricalArraysExt = "CategoricalArrays"\n    DimensionalDataChainRulesCoreExt = "ChainRulesCore"\n    DimensionalDataDiskArraysExt = "DiskArrays"\n    DimensionalDataMakieExt = "Makie"\n    DimensionalDataNearestNeighborsExt = "NearestNeighbors"\n    DimensionalDataPythonCallExt = "PythonCall"\n    DimensionalDataRecipesBaseExt = "RecipesBase"\n    DimensionalDataSparseArraysExt = "SparseArrays"\n    DimensionalDataStatsBaseExt = "StatsBase"\n\n    [deps.DimensionalData.weakdeps]\n    AbstractFFTs = "621f4979-c628-5d54-868e-fcf4e3e8185c"\n    Adapt = "79e6a3ab-5dfb-504d-930d-738a2a938a0e"\n    AlgebraOfGraphics = "cbdf2221-f076-402e-a563-3d30da359d67"\n    ArrayInterface = "4fba245c-0d91-5ea0-9b3e-6abc04ee57a9"\n    CategoricalArrays = "324d7699-5711-5eae-9e2f-1d82baa6b597"\n    ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4"\n    DiskArrays = "3c3547ce-8d99-4f5e-a174-61eb10b00ae3"\n    Makie = "ee78f7c6-11fb-53f2-987a-cfe4a2b5a57a"\n    NearestNeighbors = "b8a86587-4115-5ab1-83bc-aa920d37bbce"\n    PythonCall = "6099a3de-0909-46bc-b1f4-468b9a2dfc0d"\n    RecipesBase = "3cdcf5f2-1ef4-517c-9805-6587b60abb01"\n    SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf"\n    StatsBase = "2913bbd2-ae8a-5f71-8c99-4fb6c76f3a91"\n\n[[deps.DispatchDoctor]]\ndeps = ["MacroTools", "Preferences"]\ngit-tree-sha1 = "42cd00edaac86f941815fe557c1d01e11913e07c"\nuuid = "8d63f2c5-f18a-4cf2-ba9d-b3f60fc568c8"\nversion = "0.4.28"\n\n    [deps.DispatchDoctor.extensions]\n    DispatchDoctorChainRulesCoreExt = "ChainRulesCore"\n    DispatchDoctorEnzymeCoreExt = "EnzymeCore"\n\n    [deps.DispatchDoctor.weakdeps]\n    ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4"\n    EnzymeCore = "f151be2c-9106-41f4-ab19-57ee4f262869"\n\n[[deps.Distributed]]\ndeps = ["Random", "Serialization", "Sockets"]\nuuid = "8ba89e20-285c-5b6f-9357-94700520ee1b"\nversion = "1.11.0"\n\n[[deps.Distributions]]\ndeps = ["AliasTables", "FillArrays", "LinearAlgebra", "PDMats", "Printf", "QuadGK", "Random", "Roots", "SpecialFunctions", "Statistics", "StatsAPI", "StatsBase", "StatsFuns"]\ngit-tree-sha1 = "d2facc77c08c1c2bfb1a77c148edd05b3db5410b"\nuuid = "31c24e10-a181-5473-b8eb-7969acd0382f"\nversion = "0.25.130"\nweakdeps = ["ChainRulesCore", "DensityInterface", "SparseConnectivityTracer", "Test"]\n\n    [deps.Distributions.extensions]\n    DistributionsChainRulesCoreExt = "ChainRulesCore"\n    DistributionsDensityInterfaceExt = "DensityInterface"\n    DistributionsSparseConnectivityTracerExt = "SparseConnectivityTracer"\n    DistributionsTestExt = "Test"\n\n[[deps.DocStringExtensions]]\ngit-tree-sha1 = "7442a5dfe1ebb773c29cc2962a8980f47221d76c"\nuuid = "ffbed154-4ef7-542d-bbb7-c09d3a79fcae"\nversion = "0.9.5"\n\n[[deps.Documenter]]\ndeps = ["ANSIColoredPrinters", "AbstractTrees", "Base64", "CodecZlib", "Dates", "DocStringExtensions", "Downloads", "Git", "IOCapture", "InteractiveUtils", "JSON", "Logging", "Markdown", "MarkdownAST", "Pkg", "PrecompileTools", "REPL", "RegistryInstances", "SHA", "TOML", "Test", "Unicode"]\ngit-tree-sha1 = "56e9c37b5e7c3b4f080ab1da18d72d5c290e184a"\nuuid = "e30172f5-a6a5-5a46-863b-614d45cd2de4"\nversion = "1.17.0"\n\n[[deps.Downloads]]\ndeps = ["ArgTools", "FileWatching", "LibCURL", "NetworkOptions"]\nuuid = "f43a241f-c20a-4ad4-852c-f6b1247861c6"\nversion = "1.7.0"\n\n[[deps.DynamicPPL]]\ndeps = ["ADTypes", "AbstractMCMC", "AbstractPPL", "Accessors", "BangBang", "Bijectors", "Chairmarks", "Compat", "ConstructionBase", "Distributions", "DocStringExtensions", "FillArrays", "InteractiveUtils", "LinearAlgebra", "LogDensityProblems", "MacroTools", "OrderedCollections", "PartitionedDistributions", "PrecompileTools", "Preferences", "Printf", "Random", "Statistics", "Test"]\ngit-tree-sha1 = "2f879da24f01b7ee525dac2292654d2fc2b19dd8"\nuuid = "366bfd00-2699-11ea-058f-f148b4cae6d8"\nversion = "0.42.4"\n\n    [deps.DynamicPPL.extensions]\n    DynamicPPLComponentArraysExt = ["ComponentArrays"]\n    DynamicPPLEnzymeCoreExt = ["EnzymeCore"]\n    DynamicPPLForwardDiffExt = ["ForwardDiff"]\n    DynamicPPLMCMCChainsExt = ["MCMCChains"]\n    DynamicPPLMarginalLogDensitiesExt = ["MarginalLogDensities"]\n    DynamicPPLMooncakeExt = ["Mooncake"]\n    DynamicPPLReverseDiffExt = ["ReverseDiff"]\n\n    [deps.DynamicPPL.weakdeps]\n    ComponentArrays = "b0b7db55-cfe3-40fc-9ded-d10e2dbeff66"\n    EnzymeCore = "f151be2c-9106-41f4-ab19-57ee4f262869"\n    ForwardDiff = "f6369f11-7733-5829-9624-2563aa707210"\n    KernelAbstractions = "63c18a36-062a-441e-b654-da1e3ab1ce7c"\n    MCMCChains = "c7f686f2-ff18-58e9-bc7b-31028e88f75d"\n    MarginalLogDensities = "f0c3360a-fb8d-11e9-1194-5521fd7ee392"\n    Mooncake = "da2b9cff-9c12-43a0-ae48-6db2b0edb7d6"\n    ReverseDiff = "37e2e3b7-166d-5795-8a7a-e32c996b4267"\n\n[[deps.EllipticalSliceSampling]]\ndeps = ["AbstractMCMC", "ArrayInterface", "Distributions", "Random", "Statistics"]\ngit-tree-sha1 = "e611b7fdfbfb5b18d5e98776c30daede41b44542"\nuuid = "cad2338a-1db2-11e9-3401-43bc07c9ede2"\nversion = "2.0.0"\n\n[[deps.EnumX]]\ngit-tree-sha1 = "c49898e8438c828577f04b92fc9368c388ac783c"\nuuid = "4e289a0a-7415-4d19-859d-a7e5c4648b56"\nversion = "1.0.7"\n\n[[deps.Expat_jll]]\ndeps = ["Artifacts", "JLLWrappers", "Libdl"]\ngit-tree-sha1 = "f4d39eee89f1e58c26bf447f1d4156c0125d6838"\nuuid = "2e619515-83b5-522b-bb60-26c02a35a201"\nversion = "2.8.3+0"\n\n[[deps.ExprTools]]\ngit-tree-sha1 = "d2e49e7efd29719d6f28b891b0e0e159daa9d2b4"\nuuid = "e2ba6199-217a-4e67-a87a-7c52f15ade04"\nversion = "0.1.11"\n\n[[deps.Extents]]\ngit-tree-sha1 = "b309b36a9e02fe7be71270dd8c0fd873625332b4"\nuuid = "411431e0-e8b7-467b-b5e0-f676ba4f2910"\nversion = "0.1.6"\n\n[[deps.FastClosures]]\ngit-tree-sha1 = "acebe244d53ee1b461970f8910c235b259e772ef"\nuuid = "9aa1b823-49e4-5ca5-8b0f-3971ec8bab6a"\nversion = "0.3.2"\n\n[[deps.FileWatching]]\nuuid = "7b1f6079-737a-58dc-b8bc-7a2ca5c1b5ee"\nversion = "1.11.0"\n\n[[deps.FillArrays]]\ndeps = ["LinearAlgebra"]\ngit-tree-sha1 = "5bad39456d9f0166184fce2248783dd9862645c1"\nuuid = "1a297f60-69ca-5386-bcde-b61e274b549b"\nversion = "1.17.0"\nweakdeps = ["PDMats", "SparseArrays", "StaticArrays", "Statistics"]\n\n    [deps.FillArrays.extensions]\n    FillArraysPDMatsExt = "PDMats"\n    FillArraysSparseArraysExt = "SparseArrays"\n    FillArraysStaticArraysExt = "StaticArrays"\n    FillArraysStatisticsExt = "Statistics"\n\n[[deps.FindFirstFunctions]]\ndeps = ["PrecompileTools"]\ngit-tree-sha1 = "bba475ce782fc77777f539cf0b7c029207798db1"\nuuid = "64ca27bc-2ba2-4a57-88aa-44e436879224"\nversion = "3.2.1"\n\n[[deps.FiniteDiff]]\ndeps = ["ArrayInterface", "LinearAlgebra", "Setfield"]\ngit-tree-sha1 = "5031f23e040bf17082e5b52422d77b5e844eefb1"\nuuid = "6a86dc24-6348-571c-b903-95158fe2bd41"\nversion = "2.33.0"\n\n    [deps.FiniteDiff.extensions]\n    FiniteDiffBandedMatricesExt = "BandedMatrices"\n    FiniteDiffBlockBandedMatricesExt = "BlockBandedMatrices"\n    FiniteDiffSparseArraysExt = "SparseArrays"\n    FiniteDiffStaticArraysExt = "StaticArrays"\n\n    [deps.FiniteDiff.weakdeps]\n    BandedMatrices = "aae01518-5342-5314-be14-df237901396f"\n    BlockBandedMatrices = "ffab5731-97b5-5995-9138-79e8c1846df0"\n    SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf"\n    StaticArrays = "90137ffa-7385-5640-81b9-e52037218182"\n\n[[deps.FlexiChains]]\ndeps = ["AbstractMCMC", "AbstractPPL", "DelimitedFiles", "DimensionalData", "DocStringExtensions", "MCMCDiagnosticTools", "OrderedCollections", "PrecompileTools", "Printf", "Random", "Statistics", "StatsBase", "Tables"]\ngit-tree-sha1 = "a91b75dfee67fcf80130aea741eed9b902098305"\nuuid = "4a37a8b9-6e57-4b92-8664-298d46e639f7"\nversion = "0.6.14"\n\n    [deps.FlexiChains.extensions]\n    FlexiChainsAdvancedHMCExt = ["AdvancedHMC", "DimensionalData"]\n    FlexiChainsComponentArraysExt = ["ComponentArrays"]\n    FlexiChainsDynamicPPLExt = ["DynamicPPL", "Random", "DimensionalData", "OrderedCollections", "Distributions"]\n    FlexiChainsInferenceObjectsExt = ["InferenceObjects", "DimensionalData", "OrderedCollections"]\n    FlexiChainsMCMCChainsExt = ["MCMCChains", "OrderedCollections"]\n    FlexiChainsMakieExt = ["Makie", "StatsBase"]\n    FlexiChainsPairPlotsExt = ["PairPlots", "Makie"]\n    FlexiChainsPosteriorDBExt = ["PosteriorDB", "OrderedCollections"]\n    FlexiChainsPosteriorStatsDynamicPPLExt = ["PosteriorStats", "DynamicPPL"]\n    FlexiChainsPosteriorStatsExt = ["PosteriorStats", "DimensionalData", "IntervalSets"]\n    FlexiChainsRecipesBaseExt = ["RecipesBase", "StatsBase"]\n    FlexiChainsStanSampleExt = ["StanSample"]\n    FlexiChainsStatsPlotsExt = ["StatsPlots", "DimensionalData"]\n\n    [deps.FlexiChains.weakdeps]\n    AdvancedHMC = "0bf59076-c3b1-5ca4-86bd-e02cd72cde3d"\n    ComponentArrays = "b0b7db55-cfe3-40fc-9ded-d10e2dbeff66"\n    Distributions = "31c24e10-a181-5473-b8eb-7969acd0382f"\n    DynamicPPL = "366bfd00-2699-11ea-058f-f148b4cae6d8"\n    InferenceObjects = "b5cf5a8d-e756-4ee3-b014-01d49d192c00"\n    IntervalSets = "8197267c-284f-5f27-9208-e0e47529a953"\n    MCMCChains = "c7f686f2-ff18-58e9-bc7b-31028e88f75d"\n    Makie = "ee78f7c6-11fb-53f2-987a-cfe4a2b5a57a"\n    PairPlots = "43a3c2be-4208-490b-832a-a21dcd55d7da"\n    PosteriorDB = "1c4bc282-d2f5-44f9-b6d1-8c4424a23ad4"\n    PosteriorStats = "7f36be82-ad55-44ba-a5c0-b8b5480d7aa5"\n    RecipesBase = "3cdcf5f2-1ef4-517c-9805-6587b60abb01"\n    StanSample = "c1514b29-d3a0-5178-b312-660c88baa699"\n    StatsPlots = "f3b207a7-027a-5e70-b257-86293d7955fd"\n\n[[deps.ForwardDiff]]\ndeps = ["CommonSubexpressions", "DiffResults", "DiffRules", "LinearAlgebra", "LogExpFunctions", "NaNMath", "Preferences", "Printf", "Random", "SpecialFunctions"]\ngit-tree-sha1 = "2c5d0b0e12088cde2cf84afb2784415b1ea3dfee"\nuuid = "f6369f11-7733-5829-9624-2563aa707210"\nversion = "1.4.1"\nweakdeps = ["StaticArrays"]\n\n    [deps.ForwardDiff.extensions]\n    ForwardDiffStaticArraysExt = "StaticArrays"\n\n[[deps.FunctionWrappers]]\ngit-tree-sha1 = "d62485945ce5ae9c0c48f124a84998d755bae00e"\nuuid = "069b7b12-0de2-55c6-9aab-29f3d0a68a2e"\nversion = "1.1.3"\n\n[[deps.FunctionWrappersWrappers]]\ndeps = ["FunctionWrappers", "PrecompileTools", "SciMLPublic"]\ngit-tree-sha1 = "2bcce3ad6f6977d617928d7707fdc86ac83cce03"\nuuid = "77dc65aa-8811-40c2-897b-53d922fa7daf"\nversion = "1.13.0"\n\n    [deps.FunctionWrappersWrappers.extensions]\n    FunctionWrappersWrappersEnzymeExt = ["Enzyme", "EnzymeCore"]\n    FunctionWrappersWrappersMooncakeExt = "Mooncake"\n\n    [deps.FunctionWrappersWrappers.weakdeps]\n    Enzyme = "7da242da-08ed-463a-9acd-ee780be4f1d9"\n    EnzymeCore = "f151be2c-9106-41f4-ab19-57ee4f262869"\n    Mooncake = "da2b9cff-9c12-43a0-ae48-6db2b0edb7d6"\n\n[[deps.Functors]]\ndeps = ["Compat", "ConstructionBase", "LinearAlgebra", "Random"]\ngit-tree-sha1 = "1ac2813982db52b974c9343124ca61adbf297316"\nuuid = "d9f16b24-f501-4c13-a1f2-28368ffc5196"\nversion = "0.5.3"\n\n[[deps.Future]]\ndeps = ["Random"]\nuuid = "9fa8497b-333b-5362-9e8d-4d0656e87820"\nversion = "1.11.0"\n\n[[deps.GPUArraysCore]]\ndeps = ["Adapt"]\ngit-tree-sha1 = "83cf05ab16a73219e5f6bd1bdfa9848fa24ac627"\nuuid = "46192b85-c4d5-4398-a991-12ede77f4527"\nversion = "0.2.0"\n\n[[deps.Gamma]]\ngit-tree-sha1 = "86f86b6168a016ed88e4ae4e64577b98c3b59e8e"\nuuid = "a0844989-3bd2-4988-8bea-c9407ab0941b"\nversion = "1.1.0"\n\n[[deps.Git]]\ndeps = ["Git_LFS_jll", "Git_jll", "JLLWrappers", "OpenSSH_jll"]\ngit-tree-sha1 = "824a1890086880696fc908fe12a17bcf61738bd8"\nuuid = "d7ba0133-e1db-5d97-8f8c-041e4b3a1eb2"\nversion = "1.5.0"\n\n[[deps.Git_LFS_jll]]\ndeps = ["Artifacts", "JLLWrappers", "Libdl"]\ngit-tree-sha1 = "8c66e385d631bb934ff05e76d4a566c640c8df69"\nuuid = "020c3dae-16b3-5ae5-87b3-4cb189e250b2"\nversion = "3.7.1+0"\n\n[[deps.Git_jll]]\ndeps = ["Artifacts", "Expat_jll", "JLLWrappers", "LibCURL_jll", "Libdl", "Libiconv_jll", "OpenSSL_jll", "PCRE2_jll", "Zlib_jll"]\ngit-tree-sha1 = "7b16700f9e313c0d972d1222ede50a2076aa0770"\nuuid = "f8c6e375-362e-5223-8a59-34ff63f689eb"\nversion = "2.55.0+0"\n\n[[deps.Graphs]]\ndeps = ["ArnoldiMethod", "DataStructures", "Inflate", "LinearAlgebra", "Random", "SimpleTraits", "SparseArrays", "Statistics"]\ngit-tree-sha1 = "7eb45fe833a5b7c51cf6d89c5a841d5967e44be3"\nuuid = "86223c79-3864-5bf0-83f7-82e725a168b6"\nversion = "1.14.0"\n\n    [deps.Graphs.extensions]\n    GraphsSharedArraysExt = "SharedArrays"\n\n    [deps.Graphs.weakdeps]\n    Distributed = "8ba89e20-285c-5b6f-9357-94700520ee1b"\n    SharedArrays = "1a1011a3-84de-559e-8e89-a11a2f7dc383"\n\n[[deps.HypergeometricFunctions]]\ndeps = ["Gamma", "LinearAlgebra"]\ngit-tree-sha1 = "31bb6c92405c084617facc1d7ed9eb6c402d061e"\nuuid = "34004b35-14d8-5ef3-9330-4cdb6864b03a"\nversion = "0.3.30"\n\n[[deps.IOCapture]]\ndeps = ["Logging", "Random"]\ngit-tree-sha1 = "0ee181ec08df7d7c911901ea38baf16f755114dc"\nuuid = "b5f81e59-6552-4d32-b1f0-c071b021bf89"\nversion = "1.0.0"\n\n[[deps.Inflate]]\ngit-tree-sha1 = "d1b1b796e47d94588b3757fe84fbf65a5ec4a80d"\nuuid = "d25df0c9-e2be-5dd7-82c8-3ad0b3e990b9"\nversion = "0.1.5"\n\n[[deps.InitialValues]]\ngit-tree-sha1 = "4da0f88e9a39111c2fa3add390ab15f3a44f3ca3"\nuuid = "22cec73e-a1b8-11e9-2c92-598750a2cf9c"\nversion = "0.3.1"\n\n[[deps.InteractiveUtils]]\ndeps = ["Markdown"]\nuuid = "b77e0a4c-d291-57a0-90e8-8db25a27a240"\nversion = "1.11.0"\n\n[[deps.Interfaces]]\ngit-tree-sha1 = "331ff37738aea1a3cf841ddf085442f31b84324f"\nuuid = "85a1e053-f937-4924-92a5-1367d23b7b87"\nversion = "0.3.2"\n\n[[deps.IntervalSets]]\ngit-tree-sha1 = "79d6bd28c8d9bccc2229784f1bd637689b256377"\nuuid = "8197267c-284f-5f27-9208-e0e47529a953"\nversion = "0.7.14"\nweakdeps = ["Random", "RecipesBase", "Statistics"]\n\n    [deps.IntervalSets.extensions]\n    IntervalSetsRandomExt = "Random"\n    IntervalSetsRecipesBaseExt = "RecipesBase"\n    IntervalSetsStatisticsExt = "Statistics"\n\n[[deps.InverseFunctions]]\ngit-tree-sha1 = "a779299d77cd080bf77b97535acecd73e1c5e5cb"\nuuid = "3587e190-3f89-42d0-90ee-14403ec27112"\nversion = "0.1.17"\nweakdeps = ["Dates", "Test"]\n\n    [deps.InverseFunctions.extensions]\n    InverseFunctionsDatesExt = "Dates"\n    InverseFunctionsTestExt = "Test"\n\n[[deps.InvertedIndices]]\ngit-tree-sha1 = "6da3c4316095de0f5ee2ebd875df8721e7e0bdbe"\nuuid = "41ab1584-1d38-5bbf-9106-f11c6c58b48f"\nversion = "1.3.1"\n\n[[deps.IrrationalConstants]]\ngit-tree-sha1 = "b2d91fe939cae05960e760110b328288867b5758"\nuuid = "92d709cd-6900-40b7-9082-c6be49f344b6"\nversion = "0.2.6"\n\n[[deps.IteratorInterfaceExtensions]]\ngit-tree-sha1 = "a3f24677c21f5bbe9d2a714f95dcd58337fb2856"\nuuid = "82899510-4779-5014-852e-03e436cf321d"\nversion = "1.0.0"\n\n[[deps.JLLWrappers]]\ndeps = ["Artifacts", "Preferences"]\ngit-tree-sha1 = "7204148362dafe5fe6a273f855b8ccbe4df8173e"\nuuid = "692b3bcd-3c85-4b1f-b108-f13ce0eb3210"\nversion = "1.8.0"\n\n[[deps.JSON]]\ndeps = ["Dates", "Logging", "Parsers", "PrecompileTools", "StructUtils", "UUIDs", "Unicode"]\ngit-tree-sha1 = "c89d196f5ffb64bfbf80985b699ea913b0d2c211"\nuuid = "682c06a0-de6a-54ab-a142-c8b1cf79cde6"\nversion = "1.6.1"\n\n    [deps.JSON.extensions]\n    JSONArrowExt = ["ArrowTypes"]\n\n    [deps.JSON.weakdeps]\n    ArrowTypes = "31f734f8-188a-4ce0-8406-c8a06bd891cd"\n\n[[deps.JuliaBUGS]]\ndeps = ["ADTypes", "AbstractMCMC", "AbstractPPL", "Accessors", "AdvancedMH", "BangBang", "Bijectors", "Distributions", "Documenter", "Graphs", "JSON", "JuliaSyntax", "LinearAlgebra", "LogDensityProblems", "LogExpFunctions", "MacroTools", "MetaGraphsNext", "OrderedCollections", "PDMats", "Random", "Serialization", "SpecialFunctions", "StaticArrays", "Statistics"]\ngit-tree-sha1 = "6cba6f352b30f3414528018ce6c47e797de79961"\nuuid = "ba9fb4c0-828e-4473-b6a1-cd2560fee5bf"\nversion = "0.17.1"\n\n    [deps.JuliaBUGS.extensions]\n    JuliaBUGSAdvancedHMCExt = "AdvancedHMC"\n    JuliaBUGSFlexiChainsExt = "FlexiChains"\n    JuliaBUGSGraphMakieExt = ["GraphMakie", "GLMakie"]\n    JuliaBUGSGraphPlotExt = "GraphPlot"\n    JuliaBUGSMCMCChainsExt = "MCMCChains"\n    JuliaBUGSSliceSamplingExt = "SliceSampling"\n\n    [deps.JuliaBUGS.weakdeps]\n    AdvancedHMC = "0bf59076-c3b1-5ca4-86bd-e02cd72cde3d"\n    FlexiChains = "4a37a8b9-6e57-4b92-8664-298d46e639f7"\n    GLMakie = "e9467ef8-e4e7-5192-8a1a-b1aee30e663a"\n    GraphMakie = "1ecd5474-83a3-4783-bb4f-06765db800d2"\n    GraphPlot = "a2cc645c-3eea-5389-862e-a155d0052231"\n    MCMCChains = "c7f686f2-ff18-58e9-bc7b-31028e88f75d"\n    SliceSampling = "43f4d3e8-9711-4a8c-bd1b-03ac73a255cf"\n\n[[deps.JuliaSyntax]]\ngit-tree-sha1 = "0d4b3dab95018bcf3925204475693d9f09dc45b8"\nuuid = "70703baa-626e-46a2-a12c-08ffd08c73b4"\nversion = "1.0.2"\n\n[[deps.JuliaSyntaxHighlighting]]\ndeps = ["StyledStrings"]\nuuid = "ac6e5ff7-fb65-4e79-a425-ec3bc9c03011"\nversion = "1.12.0"\n\n[[deps.LazilyInitializedFields]]\ngit-tree-sha1 = "0f2da712350b020bc3957f269c9caad516383ee0"\nuuid = "0e77f7df-68c5-4e49-93ce-4cd80f5598bf"\nversion = "1.3.0"\n\n[[deps.LeftChildRightSiblingTrees]]\ndeps = ["AbstractTrees"]\ngit-tree-sha1 = "d4816abce26971e3237b46a47b99991f306e4832"\nuuid = "1d6d02ad-be62-4b6b-8a6d-2f90e265016e"\nversion = "0.3.0"\n\n[[deps.LibCURL]]\ndeps = ["LibCURL_jll", "MozillaCACerts_jll"]\nuuid = "b27032c2-a3e7-50c8-80cd-2d36dbcbfd21"\nversion = "0.6.4"\n\n[[deps.LibCURL_jll]]\ndeps = ["Artifacts", "LibSSH2_jll", "Libdl", "OpenSSL_jll", "Zlib_jll", "nghttp2_jll"]\nuuid = "deac9b47-8bc7-5906-a0fe-35ac56dc84c0"\nversion = "8.15.0+0"\n\n[[deps.LibGit2]]\ndeps = ["LibGit2_jll", "NetworkOptions", "Printf", "SHA"]\nuuid = "76f85450-5226-5b5a-8eaa-529ad045b433"\nversion = "1.11.0"\n\n[[deps.LibGit2_jll]]\ndeps = ["Artifacts", "LibSSH2_jll", "Libdl", "OpenSSL_jll"]\nuuid = "e37daf67-58a4-590a-8e99-b0245dd2ffc5"\nversion = "1.9.0+0"\n\n[[deps.LibSSH2_jll]]\ndeps = ["Artifacts", "Libdl", "OpenSSL_jll"]\nuuid = "29816b5a-b9ab-546f-933c-edad1886dfa8"\nversion = "1.11.3+1"\n\n[[deps.Libdl]]\nuuid = "8f399da3-3557-5675-b5ff-fb832c97cbdb"\nversion = "1.11.0"\n\n[[deps.Libiconv_jll]]\ndeps = ["Artifacts", "JLLWrappers", "Libdl"]\ngit-tree-sha1 = "be484f5c92fad0bd8acfef35fe017900b0b73809"\nuuid = "94ce4f54-9a6c-5748-9c1c-f9c7231a4531"\nversion = "1.18.0+0"\n\n[[deps.Libtask]]\ndeps = ["MistyClosures", "Test"]\ngit-tree-sha1 = "188e6364a7bb87f21e37b7545e13ab204614edf0"\nuuid = "6f1fad26-d15e-5dc8-ae53-837a1d7b8c9f"\nversion = "0.9.18"\n\n[[deps.LineSearches]]\ndeps = ["LinearAlgebra", "NLSolversBase", "NaNMath", "Printf"]\ngit-tree-sha1 = "cef1ba655e8c1f65af9d96c4fffe18bf1a3a3291"\nuuid = "d3d80556-e9d4-5f37-9878-2ab0fcc64255"\nversion = "7.7.1"\n\n[[deps.LinearAlgebra]]\ndeps = ["Libdl", "OpenBLAS_jll", "libblastrampoline_jll"]\nuuid = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"\nversion = "1.12.0"\n\n[[deps.LogDensityProblems]]\ndeps = ["ArgCheck", "DocStringExtensions", "Random"]\ngit-tree-sha1 = "d9625f27ded4ad726ceca7819394a4cc77ed25b3"\nuuid = "6fdf6af0-433a-55f7-b3ed-c6c6e0b8df7c"\nversion = "2.2.0"\n\n[[deps.LogDensityProblemsAD]]\ndeps = ["DocStringExtensions", "LogDensityProblems"]\ngit-tree-sha1 = "7b83f3ad0a8105f79a067cafbfd124827bb398d0"\nuuid = "996a588d-648d-4e1f-a8f0-a84b347e47b1"\nversion = "1.13.1"\n\n    [deps.LogDensityProblemsAD.extensions]\n    LogDensityProblemsADADTypesExt = "ADTypes"\n    LogDensityProblemsADDifferentiationInterfaceExt = ["ADTypes", "DifferentiationInterface"]\n    LogDensityProblemsADEnzymeExt = "Enzyme"\n    LogDensityProblemsADFiniteDifferencesExt = "FiniteDifferences"\n    LogDensityProblemsADForwardDiffBenchmarkToolsExt = ["BenchmarkTools", "ForwardDiff"]\n    LogDensityProblemsADForwardDiffExt = "ForwardDiff"\n    LogDensityProblemsADReverseDiffExt = "ReverseDiff"\n    LogDensityProblemsADTrackerExt = "Tracker"\n    LogDensityProblemsADZygoteExt = "Zygote"\n\n    [deps.LogDensityProblemsAD.weakdeps]\n    ADTypes = "47edcb42-4c32-4615-8424-f2b9edc5f35b"\n    BenchmarkTools = "6e4b80f9-dd63-53aa-95a3-0cdb28fa8baf"\n    DifferentiationInterface = "a0c0ee7d-e4b9-4e03-894e-1c5f64a51d63"\n    Enzyme = "7da242da-08ed-463a-9acd-ee780be4f1d9"\n    FiniteDifferences = "26cc04aa-876d-5657-8c51-4c34ba976000"\n    ForwardDiff = "f6369f11-7733-5829-9624-2563aa707210"\n    ReverseDiff = "37e2e3b7-166d-5795-8a7a-e32c996b4267"\n    Tracker = "9f7883ad-71c0-57eb-9f7f-b5c9e6d3789c"\n    Zygote = "e88e6eb3-aa80-5325-afca-941959d7151f"\n\n[[deps.LogExpFunctions]]\ndeps = ["DocStringExtensions", "IrrationalConstants", "LinearAlgebra"]\ngit-tree-sha1 = "13ca9e2586b89836fd20cccf56e57e2b9ae7f38f"\nuuid = "2ab3a3ac-af41-5b50-aa03-7779005ae688"\nversion = "0.3.29"\nweakdeps = ["ChainRulesCore", "ChangesOfVariables", "InverseFunctions"]\n\n    [deps.LogExpFunctions.extensions]\n    LogExpFunctionsChainRulesCoreExt = "ChainRulesCore"\n    LogExpFunctionsChangesOfVariablesExt = "ChangesOfVariables"\n    LogExpFunctionsInverseFunctionsExt = "InverseFunctions"\n\n[[deps.Logging]]\nuuid = "56ddb016-857b-54e1-b83d-db4d58db5568"\nversion = "1.11.0"\n\n[[deps.LoggingExtras]]\ndeps = ["Dates", "Logging"]\ngit-tree-sha1 = "f00544d95982ea270145636c181ceda21c4e2575"\nuuid = "e6f89c97-d47a-5376-807f-9c37f3926c36"\nversion = "1.2.0"\n\n[[deps.MCMCDiagnosticTools]]\ndeps = ["AbstractFFTs", "DataAPI", "DataStructures", "Distributions", "LinearAlgebra", "MLJModelInterface", "Random", "SpecialFunctions", "Statistics", "StatsBase", "StatsFuns", "Tables"]\ngit-tree-sha1 = "345bedeaf7d650f673fefa042dd8384c63de6c68"\nuuid = "be115224-59cd-429b-ad48-344e309966f0"\nversion = "0.3.19"\n\n[[deps.MLJModelInterface]]\ndeps = ["InteractiveUtils", "REPL", "Random", "ScientificTypesBase", "StatisticalTraits"]\ngit-tree-sha1 = "c275fae2e693206b4527dd9d2382aa15359ef3ed"\nuuid = "e80e1ace-859a-464e-9ed9-23947d8ae3ea"\nversion = "1.12.1"\n\n[[deps.MacroTools]]\ngit-tree-sha1 = "1e0228a030642014fe5cfe68c2c0a818f9e3f522"\nuuid = "1914dd2f-81c6-5fcd-8719-6d5c9610ff09"\nversion = "0.5.16"\n\n[[deps.MappedArrays]]\ngit-tree-sha1 = "0ee4497a4e80dbd29c058fcee6493f5219556f40"\nuuid = "dbb5928d-eab1-5f90-85c2-b9b0edb7c900"\nversion = "0.4.3"\n\n[[deps.Markdown]]\ndeps = ["Base64", "JuliaSyntaxHighlighting", "StyledStrings"]\nuuid = "d6f4376e-aef5-505a-96c1-9c027394607a"\nversion = "1.11.0"\n\n[[deps.MarkdownAST]]\ndeps = ["AbstractTrees", "Markdown"]\ngit-tree-sha1 = "93c718d892e73931841089cdc0e982d6dd9cc87b"\nuuid = "d0879d2d-cac2-40c8-9cee-1863dc0c7391"\nversion = "0.1.3"\n\n[[deps.MetaGraphsNext]]\ndeps = ["Graphs", "SimpleTraits"]\ngit-tree-sha1 = "fa3dc4a0d6569797af15f858ff012990c4afbf61"\nuuid = "fa8bd995-216d-47f1-8a91-f3b68fbeb377"\nversion = "0.8.0"\n\n    [deps.MetaGraphsNext.extensions]\n    MetaGraphsNextJLD2Ext = ["Graphs", "JLD2"]\n\n    [deps.MetaGraphsNext.weakdeps]\n    JLD2 = "033835bb-8acc-5ee8-8aae-3f567f8a3819"\n\n[[deps.Missings]]\ndeps = ["DataAPI"]\ngit-tree-sha1 = "ec4f7fbeab05d7747bdf98eb74d130a2a2ed298d"\nuuid = "e1d29d7a-bbdc-5cf2-9ac0-f12de2c33e28"\nversion = "1.2.0"\n\n[[deps.MistyClosures]]\ngit-tree-sha1 = "d1a692e293c2a0dc8fda79c04cad60582f3d4de3"\nuuid = "dbe65cb8-6be2-42dd-bbc5-4196aaced4f4"\nversion = "2.1.0"\n\n[[deps.Mmap]]\nuuid = "a63ad114-7e13-5084-954f-fe012c677804"\nversion = "1.11.0"\n\n[[deps.Mooncake]]\ndeps = ["ADTypes", "ChainRulesCore", "DispatchDoctor", "ExprTools", "LinearAlgebra", "MistyClosures", "PrecompileTools", "Random", "Test"]\ngit-tree-sha1 = "c2a14d9d10690235f270006a09cdb5aaad030199"\nuuid = "da2b9cff-9c12-43a0-ae48-6db2b0edb7d6"\nversion = "0.5.37"\n\n    [deps.Mooncake.extensions]\n    MooncakeAllocCheckExt = "AllocCheck"\n    MooncakeBFloat16sExt = "BFloat16s"\n    MooncakeCUDAExt = "CUDA"\n    MooncakeChainRulesExt = "ChainRules"\n    MooncakeDistributionsExt = "Distributions"\n    MooncakeDynamicExpressionsExt = "DynamicExpressions"\n    MooncakeFluxExt = "Flux"\n    MooncakeFunctionWrappersExt = "FunctionWrappers"\n    MooncakeJETExt = "JET"\n    MooncakeLogExpFunctionsExt = "LogExpFunctions"\n    MooncakeLuxLibExt = ["LuxLib", "MLDataDevices", "Static"]\n    MooncakeLuxLibNNlibExt = ["LuxLib", "NNlib"]\n    MooncakeLuxLibSLEEFPiratesExtension = ["LuxLib", "SLEEFPirates"]\n    MooncakeNNlibExt = ["NNlib", "LinearAlgebra"]\n    MooncakeSpecialFunctionsExt = "SpecialFunctions"\n    MooncakecuDNNExt = ["CUDA", "cuDNN"]\n\n    [deps.Mooncake.weakdeps]\n    AllocCheck = "9b6a8646-10ed-4001-bbdc-1d2f46dfbb1a"\n    BFloat16s = "ab4f0b2a-ad5b-11e8-123f-65d77653426b"\n    CUDA = "052768ef-5323-5732-b1bb-66c8b64840ba"\n    ChainRules = "082447d4-558c-5d27-93f4-14fc19e9eca2"\n    Distributions = "31c24e10-a181-5473-b8eb-7969acd0382f"\n    DynamicExpressions = "a40a106e-89c9-4ca8-8020-a735e8728b6b"\n    Flux = "587475ba-b771-5e3f-ad9e-33799f191a9c"\n    FunctionWrappers = "069b7b12-0de2-55c6-9aab-29f3d0a68a2e"\n    GPUArraysCore = "46192b85-c4d5-4398-a991-12ede77f4527"\n    JET = "c3a54625-cd67-489e-a8e7-0a5a0ff4e31b"\n    LogExpFunctions = "2ab3a3ac-af41-5b50-aa03-7779005ae688"\n    LuxLib = "82251201-b29d-42c6-8e01-566dec8acb11"\n    MLDataDevices = "7e8f7934-dd98-4c1a-8fe8-92b47a384d40"\n    NNlib = "872c559c-99b0-510c-b3b7-b6c96a88d5cd"\n    SLEEFPirates = "476501e8-09a2-5ece-8869-fb82de89a1fa"\n    SpecialFunctions = "276daf66-3868-5448-9aa4-cd146d93841b"\n    Static = "aedffcd0-7271-4cad-89d0-dc628f76c6d3"\n    cuDNN = "02a925ec-e4fe-4b08-9a7e-0d78e3d38ccd"\n\n[[deps.MozillaCACerts_jll]]\nuuid = "14a3606d-f60d-562e-9121-12d972cd8159"\nversion = "2025.11.4"\n\n[[deps.NLSolversBase]]\ndeps = ["ADTypes", "DifferentiationInterface", "FiniteDiff", "LinearAlgebra"]\ngit-tree-sha1 = "f96d38936d92d610318dec4d3b5ef37b0373c20f"\nuuid = "d41bc354-129a-5804-8e4c-c37616107c6c"\nversion = "8.0.1"\n\n[[deps.NaNMath]]\ndeps = ["OpenLibm_jll"]\ngit-tree-sha1 = "dbd2e8cd2c1c27f0b584f6661b4309609c5a685e"\nuuid = "77ba4419-2d1f-58cd-9bb1-8ffee604a2e3"\nversion = "1.1.4"\n\n[[deps.NetworkOptions]]\nuuid = "ca575930-c2e3-43a9-ace4-1e988b2c1908"\nversion = "1.3.0"\n\n[[deps.OpenBLAS_jll]]\ndeps = ["Artifacts", "CompilerSupportLibraries_jll", "Libdl"]\nuuid = "4536629a-c528-5b80-bd46-f80d51c5b363"\nversion = "0.3.29+0"\n\n[[deps.OpenLibm_jll]]\ndeps = ["Artifacts", "Libdl"]\nuuid = "05823500-19ac-5b8b-9628-191a04bc5112"\nversion = "0.8.7+0"\n\n[[deps.OpenSSH_jll]]\ndeps = ["Artifacts", "JLLWrappers", "Libdl", "OpenSSL_jll", "Zlib_jll"]\ngit-tree-sha1 = "2da18ab26a6eb38b374c16b157d5a4cc3ab74e02"\nuuid = "9bd350c2-7e96-507f-8002-3f2e150b4e1b"\nversion = "10.5.1+0"\n\n[[deps.OpenSSL_jll]]\ndeps = ["Artifacts", "Libdl"]\nuuid = "458c3c95-2e84-50aa-8efc-19380b2a3a95"\nversion = "3.5.6+0"\n\n[[deps.OpenSpecFun_jll]]\ndeps = ["Artifacts", "CompilerSupportLibraries_jll", "JLLWrappers", "Libdl"]\ngit-tree-sha1 = "1346c9208249809840c91b26703912dff463d335"\nuuid = "efe28fd5-8261-553b-a9e1-b2916fc3738e"\nversion = "0.5.6+0"\n\n[[deps.Optim]]\ndeps = ["ADTypes", "EnumX", "FillArrays", "LineSearches", "LinearAlgebra", "NLSolversBase", "NaNMath", "PositiveFactorizations", "Printf", "SparseArrays", "Statistics"]\ngit-tree-sha1 = "cbcf335fd6f959897a6ff38149736b0b5ac11264"\nuuid = "429524aa-4258-5aef-a3af-852621145aeb"\nversion = "2.2.2"\n\n    [deps.Optim.extensions]\n    OptimMOIExt = "MathOptInterface"\n\n    [deps.Optim.weakdeps]\n    MathOptInterface = "b8f27783-ece8-5eb3-8dc8-9495eed66fee"\n\n[[deps.Optimisers]]\ndeps = ["ChainRulesCore", "Compat", "ConstructionBase", "Functors", "LinearAlgebra", "Random", "Statistics"]\ngit-tree-sha1 = "b6a586b581eccc60a181145ffd4382099e32e2df"\nuuid = "3bd65402-5787-11e9-1adc-39752487f4e2"\nversion = "0.4.9"\n\n    [deps.Optimisers.extensions]\n    OptimisersAdaptExt = ["Adapt"]\n    OptimisersEnzymeCoreExt = "EnzymeCore"\n    OptimisersReactantExt = "Reactant"\n    OptimisersReactantMLDataDevicesExt = ["Reactant", "MLDataDevices"]\n\n    [deps.Optimisers.weakdeps]\n    Adapt = "79e6a3ab-5dfb-504d-930d-738a2a938a0e"\n    EnzymeCore = "f151be2c-9106-41f4-ab19-57ee4f262869"\n    MLDataDevices = "7e8f7934-dd98-4c1a-8fe8-92b47a384d40"\n    Reactant = "3c362404-f566-11ee-1572-e11a4b42c853"\n\n[[deps.Optimization]]\ndeps = ["ADTypes", "ArrayInterface", "ConsoleProgressMonitor", "DocStringExtensions", "LinearAlgebra", "Logging", "LoggingExtras", "OptimizationBase", "Printf", "Reexport", "SciMLBase", "SparseArrays", "TerminalLoggers"]\ngit-tree-sha1 = "0664920da1c020a1e7fccd826e760f517d449171"\nuuid = "7f7a1694-90dd-40f0-9382-eb1efda571ba"\nversion = "5.7.1"\n\n[[deps.OptimizationBase]]\ndeps = ["ADTypes", "ArrayInterface", "DifferentiationInterface", "DocStringExtensions", "FastClosures", "LinearAlgebra", "PrecompileTools", "SciMLBase", "SciMLLogging", "SparseArrays", "SparseConnectivityTracer", "SparseMatrixColorings", "SymbolicIndexingInterface"]\ngit-tree-sha1 = "37e44c9a2b0fadf55a57de550c9a06c35d3a1793"\nuuid = "bca83a33-5cc9-4baa-983d-23429ab6bcbb"\nversion = "5.3.0"\n\n    [deps.OptimizationBase.extensions]\n    OptimizationChainRulesCoreExt = "ChainRulesCore"\n    OptimizationEnzymeExt = ["ChainRulesCore", "Enzyme"]\n    OptimizationFiniteDiffExt = "FiniteDiff"\n    OptimizationForwardDiffExt = "ForwardDiff"\n    OptimizationMLDataDevicesExt = "MLDataDevices"\n    OptimizationMLUtilsExt = "MLUtils"\n    OptimizationMooncakeExt = "Mooncake"\n    OptimizationReverseDiffExt = "ReverseDiff"\n    OptimizationSymbolicAnalysisExt = "SymbolicAnalysis"\n    OptimizationZygoteExt = "Zygote"\n\n    [deps.OptimizationBase.weakdeps]\n    ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4"\n    Enzyme = "7da242da-08ed-463a-9acd-ee780be4f1d9"\n    FiniteDiff = "6a86dc24-6348-571c-b903-95158fe2bd41"\n    ForwardDiff = "f6369f11-7733-5829-9624-2563aa707210"\n    MLDataDevices = "7e8f7934-dd98-4c1a-8fe8-92b47a384d40"\n    MLUtils = "f1d291b0-491e-4a28-83b9-f70985020b54"\n    Mooncake = "da2b9cff-9c12-43a0-ae48-6db2b0edb7d6"\n    ReverseDiff = "37e2e3b7-166d-5795-8a7a-e32c996b4267"\n    SymbolicAnalysis = "4297ee4d-0239-47d8-ba5d-195ecdf594fe"\n    Zygote = "e88e6eb3-aa80-5325-afca-941959d7151f"\n\n[[deps.OptimizationOptimJL]]\ndeps = ["Optim", "OptimizationBase", "Reexport", "SciMLBase", "SparseArrays"]\ngit-tree-sha1 = "7a94b863f99a30bde3a36a3d2d6292f987cea743"\nuuid = "36348300-93cb-4f02-beb5-3c3902f8871e"\nversion = "0.4.18"\n\n[[deps.OrderedCollections]]\ngit-tree-sha1 = "94ba93778373a53bfd5a0caaf7d809c445292ff4"\nuuid = "bac558e1-5e72-5ebc-8fee-abe8a469f55d"\nversion = "1.8.2"\n\n[[deps.PCRE2_jll]]\ndeps = ["Artifacts", "Libdl"]\nuuid = "efcefdf7-47ab-520b-bdef-62a2eaa19f15"\nversion = "10.44.0+1"\n\n[[deps.PDMats]]\ndeps = ["LinearAlgebra", "SparseArrays", "SuiteSparse"]\ngit-tree-sha1 = "123266c25174ef6c8d4718920abc206452cf8de6"\nuuid = "90014a1f-27ba-587c-ab20-58faa44d9150"\nversion = "0.11.41"\nweakdeps = ["StatsBase"]\n\n    [deps.PDMats.extensions]\n    StatsBaseExt = "StatsBase"\n\n[[deps.Parsers]]\ndeps = ["Dates", "PrecompileTools", "UUIDs"]\ngit-tree-sha1 = "3de8f5e6e90ebfa8d6d1f86997d6cdcd6a912ff3"\nuuid = "69de0a69-1ddd-5017-9359-2bf0b02dc9f0"\nversion = "2.8.7"\n\n[[deps.PartitionedDistributions]]\ndeps = ["Distributions", "FillArrays", "InvertedIndices", "IrrationalConstants", "LinearAlgebra", "LogExpFunctions", "PDMats", "SpecialFunctions", "StatsBase"]\ngit-tree-sha1 = "621944b594bec8df388aeecd2d694824cbe71ecd"\nuuid = "569bd051-8d7b-4221-bcb8-d78512b5866a"\nversion = "0.1.0"\n\n[[deps.Pkg]]\ndeps = ["Artifacts", "Dates", "Downloads", "FileWatching", "LibGit2", "Libdl", "Logging", "Markdown", "Printf", "Random", "SHA", "TOML", "Tar", "UUIDs", "p7zip_jll"]\nuuid = "44cfe95a-1eb2-52ea-b672-e2afdf69b78f"\nversion = "1.12.1"\nweakdeps = ["REPL"]\n\n    [deps.Pkg.extensions]\n    REPLExt = "REPL"\n\n[[deps.PositiveFactorizations]]\ndeps = ["LinearAlgebra"]\ngit-tree-sha1 = "17275485f373e6673f7e7f97051f703ed5b15b20"\nuuid = "85a6dd25-e78a-55b7-8502-1745935b8125"\nversion = "0.2.4"\n\n[[deps.PreallocationTools]]\ndeps = ["Adapt", "ArrayInterface", "PrecompileTools", "SciMLPublic"]\ngit-tree-sha1 = "5e1c95fb1366c7f92c44839b22fc362257895a34"\nuuid = "d236fae5-4411-538c-8e31-a6e3d9e00b46"\nversion = "1.5.0"\n\n    [deps.PreallocationTools.extensions]\n    PreallocationToolsEnzymeCoreExt = "EnzymeCore"\n    PreallocationToolsForwardDiffExt = "ForwardDiff"\n    PreallocationToolsReverseDiffExt = "ReverseDiff"\n\n    [deps.PreallocationTools.weakdeps]\n    EnzymeCore = "f151be2c-9106-41f4-ab19-57ee4f262869"\n    ForwardDiff = "f6369f11-7733-5829-9624-2563aa707210"\n    ReverseDiff = "37e2e3b7-166d-5795-8a7a-e32c996b4267"\n\n[[deps.PrecompileTools]]\ndeps = ["Preferences"]\ngit-tree-sha1 = "edbeefc7a4889f528644251bdb5fc9ab5348bc2c"\nuuid = "aea7be01-6a6a-4083-8856-8a6e6704d82a"\nversion = "1.3.4"\n\n[[deps.Preferences]]\ndeps = ["TOML"]\ngit-tree-sha1 = "8b770b60760d4451834fe79dd483e318eee709c4"\nuuid = "21216c6a-2e73-6563-6e65-726566657250"\nversion = "1.5.2"\n\n[[deps.Printf]]\ndeps = ["Unicode"]\nuuid = "de0858da-6303-5e67-8744-51eddeeeb8d7"\nversion = "1.11.0"\n\n[[deps.ProgressLogging]]\ndeps = ["Logging", "SHA", "UUIDs"]\ngit-tree-sha1 = "f0803bc1171e455a04124affa9c21bba5ac4db32"\nuuid = "33c8b6b6-d38a-422a-b730-caa89a2f386c"\nversion = "0.1.6"\n\n[[deps.ProgressMeter]]\ndeps = ["Distributed", "Printf"]\ngit-tree-sha1 = "fbb92c6c56b34e1a2c4c36058f68f332bec840e7"\nuuid = "92933f4c-e287-5a05-a399-4b506db050ca"\nversion = "1.11.0"\n\n[[deps.PtrArrays]]\ngit-tree-sha1 = "4fbbafbc6251b883f4d2705356f3641f3652a7fe"\nuuid = "43287f4e-b6f4-7ad1-bb20-aadabca52c3d"\nversion = "1.4.0"\n\n[[deps.QuadGK]]\ndeps = ["DataStructures", "LinearAlgebra"]\ngit-tree-sha1 = "5e8e8b0ab68215d7a2b14b9921a946fee794749e"\nuuid = "1fd47b50-473d-5c70-9696-f719f8f3bcdc"\nversion = "2.11.3"\n\n    [deps.QuadGK.extensions]\n    QuadGKEnzymeExt = "Enzyme"\n\n    [deps.QuadGK.weakdeps]\n    Enzyme = "7da242da-08ed-463a-9acd-ee780be4f1d9"\n\n[[deps.REPL]]\ndeps = ["InteractiveUtils", "JuliaSyntaxHighlighting", "Markdown", "Sockets", "StyledStrings", "Unicode"]\nuuid = "3fa0cd96-eef1-5676-8a61-b3b8758bbffb"\nversion = "1.11.0"\n\n[[deps.Random]]\ndeps = ["SHA"]\nuuid = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c"\nversion = "1.11.0"\n\n[[deps.Random123]]\ndeps = ["Random", "RandomNumbers"]\ngit-tree-sha1 = "dbe5fd0b334694e905cb9fda73cd8554333c46e2"\nuuid = "74087812-796a-5b5d-8853-05524746bad3"\nversion = "1.7.1"\n\n[[deps.RandomNumbers]]\ndeps = ["Random"]\ngit-tree-sha1 = "c6ec94d2aaba1ab2ff983052cf6a606ca5985902"\nuuid = "e6cf234a-135c-5ec9-84dd-332b85af5143"\nversion = "1.6.0"\n\n[[deps.RecipesBase]]\ndeps = ["PrecompileTools"]\ngit-tree-sha1 = "5c3d09cc4f31f5fc6af001c250bf1278733100ff"\nuuid = "3cdcf5f2-1ef4-517c-9805-6587b60abb01"\nversion = "1.3.4"\n\n[[deps.RecursiveArrayTools]]\ndeps = ["Adapt", "ArrayInterface", "GPUArraysCore", "LinearAlgebra", "PrecompileTools", "RecipesBase", "SciMLPublic", "SciMLStructures", "StaticArraysCore", "SymbolicIndexingInterface"]\ngit-tree-sha1 = "58c6496ceca7aafbd8534602f9a901c3ffc4b709"\nuuid = "731186ca-8d62-57ce-b412-fbd966d074cd"\nversion = "4.5.0"\n\n    [deps.RecursiveArrayTools.extensions]\n    RecursiveArrayToolsCUDAExt = "CUDA"\n    RecursiveArrayToolsFastBroadcastExt = "FastBroadcast"\n    RecursiveArrayToolsFastBroadcastPolyesterExt = ["FastBroadcast", "Polyester"]\n    RecursiveArrayToolsForwardDiffExt = "ForwardDiff"\n    RecursiveArrayToolsKernelAbstractionsExt = "KernelAbstractions"\n    RecursiveArrayToolsMeasurementsExt = "Measurements"\n    RecursiveArrayToolsMonteCarloMeasurementsExt = "MonteCarloMeasurements"\n    RecursiveArrayToolsMooncakeExt = "Mooncake"\n    RecursiveArrayToolsReverseDiffExt = ["ReverseDiff", "Zygote"]\n    RecursiveArrayToolsSparseArraysExt = ["SparseArrays"]\n    RecursiveArrayToolsStatisticsExt = "Statistics"\n    RecursiveArrayToolsStructArraysExt = "StructArrays"\n    RecursiveArrayToolsTablesExt = ["Tables"]\n    RecursiveArrayToolsTrackerExt = "Tracker"\n    RecursiveArrayToolsZygoteExt = "Zygote"\n\n    [deps.RecursiveArrayTools.weakdeps]\n    CUDA = "052768ef-5323-5732-b1bb-66c8b64840ba"\n    FastBroadcast = "7034ab61-46d4-4ed7-9d0f-46aef9175898"\n    ForwardDiff = "f6369f11-7733-5829-9624-2563aa707210"\n    KernelAbstractions = "63c18a36-062a-441e-b654-da1e3ab1ce7c"\n    Measurements = "eff96d63-e80a-5855-80a2-b1b0885c5ab7"\n    MonteCarloMeasurements = "0987c9cc-fe09-11e8-30f0-b96dd679fdca"\n    Mooncake = "da2b9cff-9c12-43a0-ae48-6db2b0edb7d6"\n    Polyester = "f517fe37-dbe3-4b94-8317-1923a5111588"\n    ReverseDiff = "37e2e3b7-166d-5795-8a7a-e32c996b4267"\n    SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf"\n    Statistics = "10745b16-79ce-11e8-11f9-7d13ad32a3b2"\n    StructArrays = "09ab397b-f2b6-538f-b94a-2f83cf4a842a"\n    Tables = "bd369af6-aec1-5ad0-b16a-f7cc5008161c"\n    Tracker = "9f7883ad-71c0-57eb-9f7f-b5c9e6d3789c"\n    Zygote = "e88e6eb3-aa80-5325-afca-941959d7151f"\n\n[[deps.Reexport]]\ngit-tree-sha1 = "45e428421666073eab6f2da5c9d310d99bb12f9b"\nuuid = "189a3867-3050-52da-a836-e630ba90ab69"\nversion = "1.2.2"\n\n[[deps.RegistryInstances]]\ndeps = ["LazilyInitializedFields", "Pkg", "TOML", "Tar"]\ngit-tree-sha1 = "ffd19052caf598b8653b99404058fce14828be51"\nuuid = "2792f1a3-b283-48e8-9a74-f99dce5104f3"\nversion = "0.1.0"\n\n[[deps.Requires]]\ndeps = ["UUIDs"]\ngit-tree-sha1 = "62389eeff14780bfe55195b7204c0d8738436d64"\nuuid = "ae029012-a4dd-5104-9daa-d747884805df"\nversion = "1.3.1"\n\n[[deps.ReverseDiff]]\ndeps = ["ChainRulesCore", "DiffResults", "DiffRules", "ForwardDiff", "FunctionWrappers", "LinearAlgebra", "LogExpFunctions", "MacroTools", "NaNMath", "Random", "SpecialFunctions", "StaticArrays", "Statistics"]\ngit-tree-sha1 = "f5f3c09103951beae390666a18e084655996370b"\nuuid = "37e2e3b7-166d-5795-8a7a-e32c996b4267"\nversion = "1.17.0"\n\n[[deps.Rmath]]\ndeps = ["Random", "Rmath_jll"]\ngit-tree-sha1 = "5b3d50eb374cea306873b371d3f8d3915a018f0b"\nuuid = "79098fc4-a85e-5d69-aa6a-4863f24498fa"\nversion = "0.9.0"\n\n[[deps.Rmath_jll]]\ndeps = ["Artifacts", "JLLWrappers", "Libdl"]\ngit-tree-sha1 = "6d40b2fe70437b01397d2a4d5b020008da4e7019"\nuuid = "f50d1b31-88e8-58de-be2c-1cc44531875f"\nversion = "0.5.2+0"\n\n[[deps.Roots]]\ndeps = ["Accessors", "CommonSolve", "Printf"]\ngit-tree-sha1 = "7fb25a964849d90a0446366cdefca822e0e84900"\nuuid = "f2b01f46-fcfa-551c-844a-d8ac1e96c665"\nversion = "3.0.6"\n\n    [deps.Roots.extensions]\n    RootsChainRulesCoreExt = "ChainRulesCore"\n    RootsForwardDiffExt = "ForwardDiff"\n    RootsIntervalRootFindingExt = "IntervalRootFinding"\n    RootsSymPyExt = "SymPy"\n    RootsSymPyPythonCallExt = "SymPyPythonCall"\n    RootsUnitfulExt = "Unitful"\n\n    [deps.Roots.weakdeps]\n    ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4"\n    ForwardDiff = "f6369f11-7733-5829-9624-2563aa707210"\n    IntervalRootFinding = "d2bf35a9-74e0-55ec-b149-d360ff49b807"\n    SymPy = "24249f21-da20-56a4-8eb1-6a02cf4ae2e6"\n    SymPyPythonCall = "bc8888f7-b21e-4b7c-a06a-5d9c9496438c"\n    Unitful = "1986cc42-f94f-5a68-af5c-568840ba703d"\n\n[[deps.RuntimeGeneratedFunctions]]\ndeps = ["ExprTools", "SHA", "Serialization"]\ngit-tree-sha1 = "65c9e1142f0372bfc16ba14b9edd57737fe0039f"\nuuid = "7e49a35a-f44a-4d26-94aa-eba1b4ca6b47"\nversion = "0.5.24"\n\n[[deps.SHA]]\nuuid = "ea8e919c-243c-51af-8825-aaa63cd721ce"\nversion = "0.7.0"\n\n[[deps.SSMProblems]]\ndeps = ["AbstractMCMC", "Distributions", "Random"]\ngit-tree-sha1 = "cbf723e4c486375cf91236db53a7beefe8291951"\nuuid = "26aad666-b158-4e64-9d35-0e672562fa48"\nversion = "0.6.1"\n\n[[deps.SciMLBase]]\ndeps = ["ADTypes", "Accessors", "Adapt", "ArrayInterface", "CommonSolve", "ConstructionBase", "Distributed", "DocStringExtensions", "EnumX", "FindFirstFunctions", "FunctionWrappersWrappers", "IteratorInterfaceExtensions", "LinearAlgebra", "Logging", "LoggingExtras", "Markdown", "PreallocationTools", "PrecompileTools", "Preferences", "Printf", "Random", "RecipesBase", "RecursiveArrayTools", "RuntimeGeneratedFunctions", "SciMLOperators", "SciMLPublic", "SciMLStructures", "StaticArraysCore", "Statistics", "SymbolicIndexingInterface"]\ngit-tree-sha1 = "ecef3adefb299e19a08d03ebb60d7c2a8e5db3d9"\nuuid = "0bca4576-84f4-4d90-8ffe-ffa030f20462"\nversion = "3.49.1"\n\n    [deps.SciMLBase.extensions]\n    SciMLBaseChainRulesCoreExt = "ChainRulesCore"\n    SciMLBaseDifferentiationInterfaceExt = "DifferentiationInterface"\n    SciMLBaseDistributionsExt = "Distributions"\n    SciMLBaseEnzymeExt = "Enzyme"\n    SciMLBaseForwardDiffExt = "ForwardDiff"\n    SciMLBaseFunctionPropertiesExt = "FunctionProperties"\n    SciMLBaseMakieExt = ["Makie", "GeometryBasics"]\n    SciMLBaseMeasurementsExt = "Measurements"\n    SciMLBaseMonteCarloMeasurementsExt = "MonteCarloMeasurements"\n    SciMLBaseMooncakeExt = "Mooncake"\n    SciMLBasePartialFunctionsExt = "PartialFunctions"\n    SciMLBasePyCallExt = "PyCall"\n    SciMLBasePythonCallExt = "PythonCall"\n    SciMLBaseRCallExt = "RCall"\n    SciMLBaseReverseDiffExt = ["ReverseDiff", "ForwardDiff"]\n    SciMLBaseStaticArraysExt = "StaticArrays"\n    SciMLBaseTrackerExt = "Tracker"\n    SciMLBaseZygoteExt = ["Zygote", "ChainRulesCore", "ZygoteRules", "FillArrays"]\n\n    [deps.SciMLBase.weakdeps]\n    ChainRules = "082447d4-558c-5d27-93f4-14fc19e9eca2"\n    ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4"\n    DifferentiationInterface = "a0c0ee7d-e4b9-4e03-894e-1c5f64a51d63"\n    Distributions = "31c24e10-a181-5473-b8eb-7969acd0382f"\n    Enzyme = "7da242da-08ed-463a-9acd-ee780be4f1d9"\n    FillArrays = "1a297f60-69ca-5386-bcde-b61e274b549b"\n    ForwardDiff = "f6369f11-7733-5829-9624-2563aa707210"\n    FunctionProperties = "f62d2435-5019-4c03-9749-2d4c77af0cbc"\n    GeometryBasics = "5c1252a2-5f33-56bf-86c9-59e7332b4326"\n    Makie = "ee78f7c6-11fb-53f2-987a-cfe4a2b5a57a"\n    Measurements = "eff96d63-e80a-5855-80a2-b1b0885c5ab7"\n    MonteCarloMeasurements = "0987c9cc-fe09-11e8-30f0-b96dd679fdca"\n    Mooncake = "da2b9cff-9c12-43a0-ae48-6db2b0edb7d6"\n    PartialFunctions = "570af359-4316-4cb7-8c74-252c00c2016b"\n    PyCall = "438e738f-606a-5dbb-bf0a-cddfbfd45ab0"\n    PythonCall = "6099a3de-0909-46bc-b1f4-468b9a2dfc0d"\n    RCall = "6f49c342-dc21-5d91-9882-a32aef131414"\n    ReverseDiff = "37e2e3b7-166d-5795-8a7a-e32c996b4267"\n    StaticArrays = "90137ffa-7385-5640-81b9-e52037218182"\n    Tracker = "9f7883ad-71c0-57eb-9f7f-b5c9e6d3789c"\n    Zygote = "e88e6eb3-aa80-5325-afca-941959d7151f"\n    ZygoteRules = "700de1a5-db45-46bc-99cf-38207098b444"\n\n[[deps.SciMLLogging]]\ndeps = ["Logging", "LoggingExtras", "Preferences"]\ngit-tree-sha1 = "36be2198d9dc476ac27efb1fe0f789d9e1dca01c"\nuuid = "a6db7da4-7206-11f0-1eab-35f2a5dbe1d1"\nversion = "2.0.4"\n\n    [deps.SciMLLogging.extensions]\n    SciMLLoggingTracyExt = "Tracy"\n\n    [deps.SciMLLogging.weakdeps]\n    Tracy = "e689c965-62c8-4b79-b2c5-8359227902fd"\n\n[[deps.SciMLOperators]]\ndeps = ["Accessors", "Adapt", "ArrayInterface", "DocStringExtensions", "LinearAlgebra", "SciMLPublic"]\ngit-tree-sha1 = "fdba76643b52cc34baeda645b7a0c9a7a89db01a"\nuuid = "c0aeaf25-5076-4817-a8d5-81caf7dfa961"\nversion = "1.28.0"\n\n    [deps.SciMLOperators.extensions]\n    SciMLOperatorsLoopVectorizationExt = "LoopVectorization"\n    SciMLOperatorsSparseArraysExt = "SparseArrays"\n\n    [deps.SciMLOperators.weakdeps]\n    LoopVectorization = "bdcacae8-1622-11e9-2a5c-532679323890"\n    SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf"\n\n[[deps.SciMLPublic]]\ngit-tree-sha1 = "cf9aaf8b9ed5db993259ea8b24cf2b7ba9bd3b79"\nuuid = "431bcebd-1456-4ced-9d72-93c2757fff0b"\nversion = "1.2.4"\n\n[[deps.SciMLStructures]]\ndeps = ["ArrayInterface", "PrecompileTools"]\ngit-tree-sha1 = "53bf620cb2c3763d41495b2a145611c6ca400dcd"\nuuid = "53ae85a6-f571-4167-b2af-e1d143709226"\nversion = "1.10.4"\n\n[[deps.ScientificTypesBase]]\ndeps = ["InteractiveUtils"]\ngit-tree-sha1 = "e785eaa35a0f5518a388f9010e66fda64ea95ede"\nuuid = "30f210dd-8aff-4c5f-94ba-8e64358c1161"\nversion = "3.1.0"\n\n[[deps.Serialization]]\nuuid = "9e88b42a-f829-5b0c-bbe9-9e923198166b"\nversion = "1.11.0"\n\n[[deps.Setfield]]\ndeps = ["ConstructionBase", "Future", "MacroTools", "StaticArraysCore"]\ngit-tree-sha1 = "c5391c6ace3bc430ca630251d02ea9687169ca68"\nuuid = "efcf1570-3423-57d1-acb7-fd33fddbac46"\nversion = "1.1.2"\n\n[[deps.SimpleTraits]]\ndeps = ["InteractiveUtils", "MacroTools"]\ngit-tree-sha1 = "7ddb0b49c109481b046972c0e4ab02b2127d6a75"\nuuid = "699a6c99-e7fa-54fc-8d76-47d257e15c1d"\nversion = "0.9.6"\n\n[[deps.SliceSampling]]\ndeps = ["AbstractMCMC", "Accessors", "Distributions", "LinearAlgebra", "LogDensityProblems", "Random"]\ngit-tree-sha1 = "680f498b0e24c5b6b319e60b7e760750e0ab37b5"\nuuid = "43f4d3e8-9711-4a8c-bd1b-03ac73a255cf"\nversion = "0.7.12"\n\n[[deps.Sockets]]\nuuid = "6462fe0b-24de-5631-8697-dd941f90decc"\nversion = "1.11.0"\n\n[[deps.SortingAlgorithms]]\ndeps = ["DataStructures"]\ngit-tree-sha1 = "13cd91cc9be159e3f4d95b857fa2aa383b53772a"\nuuid = "a2af1166-a08f-5f64-846c-94a0d3cef48c"\nversion = "1.2.3"\n\n[[deps.SparseArrays]]\ndeps = ["Libdl", "LinearAlgebra", "Random", "Serialization", "SuiteSparse_jll"]\nuuid = "2f01184e-e22b-5df5-ae63-d93ebab69eaf"\nversion = "1.12.0"\n\n[[deps.SparseConnectivityTracer]]\ndeps = ["ADTypes", "DocStringExtensions", "FillArrays", "LinearAlgebra", "Random", "SparseArrays"]\ngit-tree-sha1 = "ad4d1275eeb223cbd4d362563954a661fe12d2f7"\nuuid = "9f842d2f-2579-4b1d-911e-f412cf18a3f5"\nversion = "1.2.2"\n\n    [deps.SparseConnectivityTracer.extensions]\n    SparseConnectivityTracerChainRulesCoreExt = "ChainRulesCore"\n    SparseConnectivityTracerLogExpFunctionsExt = "LogExpFunctions"\n    SparseConnectivityTracerNNlibExt = "NNlib"\n    SparseConnectivityTracerNaNMathExt = "NaNMath"\n    SparseConnectivityTracerSpecialFunctionsExt = "SpecialFunctions"\n\n    [deps.SparseConnectivityTracer.weakdeps]\n    ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4"\n    LogExpFunctions = "2ab3a3ac-af41-5b50-aa03-7779005ae688"\n    NNlib = "872c559c-99b0-510c-b3b7-b6c96a88d5cd"\n    NaNMath = "77ba4419-2d1f-58cd-9bb1-8ffee604a2e3"\n    SpecialFunctions = "276daf66-3868-5448-9aa4-cd146d93841b"\n\n[[deps.SparseMatrixColorings]]\ndeps = ["ADTypes", "DocStringExtensions", "LinearAlgebra", "PrecompileTools", "Random", "SparseArrays"]\ngit-tree-sha1 = "f63d76c7b7c329cf11badd564fd8ba877b09c3fe"\nuuid = "0a514795-09f3-496d-8182-132a7b665d35"\nversion = "0.4.27"\n\n    [deps.SparseMatrixColorings.extensions]\n    SparseMatrixColoringsCUDAExt = ["CUDA", "cuSPARSE"]\n    SparseMatrixColoringsCliqueTreesExt = "CliqueTrees"\n    SparseMatrixColoringsColorsExt = "Colors"\n    SparseMatrixColoringsGPUArraysExt = "GPUArrays"\n    SparseMatrixColoringsJuMPExt = ["JuMP", "MathOptInterface"]\n\n    [deps.SparseMatrixColorings.weakdeps]\n    CUDA = "052768ef-5323-5732-b1bb-66c8b64840ba"\n    CliqueTrees = "60701a23-6482-424a-84db-faee86b9b1f8"\n    Colors = "5ae59095-9a9b-59fe-a467-6f913c188581"\n    GPUArrays = "0c68f7d7-f131-5f86-a1c3-88cf8149b2d7"\n    JuMP = "4076af6c-e467-56ae-b986-b466b2749572"\n    MathOptInterface = "b8f27783-ece8-5eb3-8dc8-9495eed66fee"\n    cuSPARSE = "b26da814-b3bc-49ef-b0ee-c816305aa060"\n\n[[deps.SpecialFunctions]]\ndeps = ["IrrationalConstants", "LogExpFunctions", "OpenLibm_jll", "OpenSpecFun_jll"]\ngit-tree-sha1 = "429071b23f4c9a13fb6582f807cc2ef454082408"\nuuid = "276daf66-3868-5448-9aa4-cd146d93841b"\nversion = "2.9.0"\nweakdeps = ["ChainRulesCore"]\n\n    [deps.SpecialFunctions.extensions]\n    SpecialFunctionsChainRulesCoreExt = "ChainRulesCore"\n\n[[deps.StableRNGs]]\ndeps = ["Random"]\ngit-tree-sha1 = "4f96c596b8c8258cc7d3b19797854d368f243ddc"\nuuid = "860ef19b-820b-49d6-a774-d7a799459cd3"\nversion = "1.0.4"\n\n[[deps.StaticArrays]]\ndeps = ["LinearAlgebra", "PrecompileTools", "Random", "StaticArraysCore"]\ngit-tree-sha1 = "fac51faf3bb96e8bc0bf6f9f39ca4955652776bb"\nuuid = "90137ffa-7385-5640-81b9-e52037218182"\nversion = "1.9.19"\nweakdeps = ["ChainRulesCore", "Statistics"]\n\n    [deps.StaticArrays.extensions]\n    StaticArraysChainRulesCoreExt = "ChainRulesCore"\n    StaticArraysStatisticsExt = "Statistics"\n\n[[deps.StaticArraysCore]]\ngit-tree-sha1 = "6ab403037779dae8c514bad259f32a447262455a"\nuuid = "1e83bf80-4336-4d27-bf5d-d5a4f845583c"\nversion = "1.4.4"\n\n[[deps.StatisticalTraits]]\ndeps = ["ScientificTypesBase"]\ngit-tree-sha1 = "89f86d9376acd18a1a4fbef66a56335a3a7633b8"\nuuid = "64bff920-2084-43da-a3e6-9bb72801c0c9"\nversion = "3.5.0"\n\n[[deps.Statistics]]\ndeps = ["LinearAlgebra"]\ngit-tree-sha1 = "ae3bb1eb3bba077cd276bc5cfc337cc65c3075c0"\nuuid = "10745b16-79ce-11e8-11f9-7d13ad32a3b2"\nversion = "1.11.1"\nweakdeps = ["SparseArrays"]\n\n    [deps.Statistics.extensions]\n    SparseArraysExt = ["SparseArrays"]\n\n[[deps.StatsAPI]]\ndeps = ["LinearAlgebra"]\ngit-tree-sha1 = "178ed29fd5b2a2cfc3bd31c13375ae925623ff36"\nuuid = "82ae8749-77ed-4fe6-ae5f-f523153014b0"\nversion = "1.8.0"\n\n[[deps.StatsBase]]\ndeps = ["AliasTables", "DataAPI", "DataStructures", "IrrationalConstants", "LinearAlgebra", "LogExpFunctions", "Missings", "Printf", "Random", "SortingAlgorithms", "SparseArrays", "Statistics", "StatsAPI"]\ngit-tree-sha1 = "e4d7a1a0edc20af42689ea6f4f3587a2175d50ee"\nuuid = "2913bbd2-ae8a-5f71-8c99-4fb6c76f3a91"\nversion = "0.34.12"\n\n[[deps.StatsFuns]]\ndeps = ["HypergeometricFunctions", "IrrationalConstants", "LogExpFunctions", "Reexport", "Rmath", "SpecialFunctions"]\ngit-tree-sha1 = "91f091a8716a6bb38417a6e6f274602a19aaa685"\nuuid = "4c63d2b9-4356-54db-8cca-17b64c39e42c"\nversion = "1.5.2"\nweakdeps = ["ChainRulesCore", "InverseFunctions"]\n\n    [deps.StatsFuns.extensions]\n    StatsFunsChainRulesCoreExt = "ChainRulesCore"\n    StatsFunsInverseFunctionsExt = "InverseFunctions"\n\n[[deps.StructUtils]]\ndeps = ["Dates", "UUIDs"]\ngit-tree-sha1 = "2d0fc55c61321ba245c47be599570d11bac50303"\nuuid = "ec057cc2-7a8d-4b58-b3b3-92acb9f63b42"\nversion = "2.8.5"\n\n    [deps.StructUtils.extensions]\n    StructUtilsMeasurementsExt = ["Measurements"]\n    StructUtilsStaticArraysCoreExt = ["StaticArraysCore"]\n    StructUtilsTablesExt = ["Tables"]\n\n    [deps.StructUtils.weakdeps]\n    Measurements = "eff96d63-e80a-5855-80a2-b1b0885c5ab7"\n    StaticArraysCore = "1e83bf80-4336-4d27-bf5d-d5a4f845583c"\n    Tables = "bd369af6-aec1-5ad0-b16a-f7cc5008161c"\n\n[[deps.StyledStrings]]\nuuid = "f489334b-da3d-4c2e-b8f0-e476e12c162b"\nversion = "1.11.0"\n\n[[deps.SuiteSparse]]\ndeps = ["Libdl", "LinearAlgebra", "Serialization", "SparseArrays"]\nuuid = "4607b0f0-06f3-5cda-b6b1-a6196a1729e9"\n\n[[deps.SuiteSparse_jll]]\ndeps = ["Artifacts", "Libdl", "libblastrampoline_jll"]\nuuid = "bea87d4a-7f5b-5778-9afe-8cc45184846c"\nversion = "7.8.3+2"\n\n[[deps.SymbolicIndexingInterface]]\ndeps = ["Accessors", "ArrayInterface", "RuntimeGeneratedFunctions", "StaticArraysCore"]\ngit-tree-sha1 = "2167b9913f3013a1485bdc9bb249123eb8b53cb0"\nuuid = "2efcf032-c050-4f8e-a9bb-153293bab1f5"\nversion = "0.3.54"\n\n    [deps.SymbolicIndexingInterface.extensions]\n    SymbolicIndexingInterfacePrettyTablesExt = "PrettyTables"\n\n    [deps.SymbolicIndexingInterface.weakdeps]\n    PrettyTables = "08abe8d2-0d0c-5749-adfa-8a2ac140af0d"\n\n[[deps.TOML]]\ndeps = ["Dates"]\nuuid = "fa267f1f-6049-4f14-aa54-33bafae1ed76"\nversion = "1.0.3"\n\n[[deps.TableTraits]]\ndeps = ["IteratorInterfaceExtensions"]\ngit-tree-sha1 = "c06b2f539df1c6efa794486abfb6ed2022561a39"\nuuid = "3783bdb8-4a98-5b6b-af9a-565f29a5fe9c"\nversion = "1.0.1"\n\n[[deps.Tables]]\ndeps = ["DataAPI", "DataValueInterfaces", "IteratorInterfaceExtensions", "OrderedCollections", "TableTraits"]\ngit-tree-sha1 = "0f38a06c83f0007bbab3cf911262841c9a0f07e0"\nuuid = "bd369af6-aec1-5ad0-b16a-f7cc5008161c"\nversion = "1.13.0"\n\n[[deps.Tar]]\ndeps = ["ArgTools", "SHA"]\nuuid = "a4e569a6-e804-4fa4-b0f3-eef7a1d5b13e"\nversion = "1.10.0"\n\n[[deps.TerminalLoggers]]\ndeps = ["LeftChildRightSiblingTrees", "Logging", "Markdown", "Printf", "ProgressLogging", "UUIDs"]\ngit-tree-sha1 = "81c9b4137edfe56a56efcdcb35d721b2ce3e2416"\nuuid = "5d786b92-1e48-4d6f-9151-6b4477ca9bed"\nversion = "0.1.8"\n\n[[deps.Test]]\ndeps = ["InteractiveUtils", "Logging", "Random", "Serialization"]\nuuid = "8dfed614-e22c-5e08-85e1-65c5234f0b40"\nversion = "1.11.0"\n\n[[deps.TranscodingStreams]]\ngit-tree-sha1 = "0c45878dcfdcfa8480052b6ab162cdd138781742"\nuuid = "3bb67fe8-82b1-5028-8e26-92a6c54297fa"\nversion = "0.11.3"\n\n[[deps.Turing]]\ndeps = ["ADTypes", "AbstractMCMC", "AbstractPPL", "Accessors", "AdvancedHMC", "AdvancedMH", "AdvancedPS", "AdvancedVI", "BangBang", "Bijectors", "Compat", "DataStructures", "Distributions", "DocStringExtensions", "DynamicPPL", "EllipticalSliceSampling", "FlexiChains", "ForwardDiff", "Libtask", "LinearAlgebra", "LogDensityProblems", "Optimization", "OptimizationOptimJL", "OrderedCollections", "Printf", "Random", "Reexport", "SciMLBase", "SpecialFunctions", "Statistics", "StatsAPI", "StatsBase", "StatsFuns"]\ngit-tree-sha1 = "36243b86c346ac2329f931b31d00c0f147f77381"\nuuid = "fce5fe82-541a-59a6-adf8-730c64b5f9a0"\nversion = "0.46.0"\n\n    [deps.Turing.extensions]\n    TuringDynamicHMCExt = "DynamicHMC"\n    TuringMCMCChainsExt = "MCMCChains"\n\n    [deps.Turing.weakdeps]\n    DynamicHMC = "bbc10e6e-7c05-544b-b16e-64fede858acb"\n    MCMCChains = "c7f686f2-ff18-58e9-bc7b-31028e88f75d"\n\n[[deps.UUIDs]]\ndeps = ["Random", "SHA"]\nuuid = "cf7118a7-6976-5b1a-9a39-7adc72f591a4"\nversion = "1.11.0"\n\n[[deps.Unicode]]\nuuid = "4ec0a83e-493e-50e2-b9ac-8f72acf5a8f5"\nversion = "1.11.0"\n\n[[deps.Zlib_jll]]\ndeps = ["Libdl"]\nuuid = "83775a58-1f1d-513f-b197-d71354ab007a"\nversion = "1.3.1+2"\n\n[[deps.libblastrampoline_jll]]\ndeps = ["Artifacts", "Libdl"]\nuuid = "8e850b90-86db-534c-a0d3-1478176c7d93"\nversion = "5.15.0+0"\n\n[[deps.nghttp2_jll]]\ndeps = ["Artifacts", "Libdl"]\nuuid = "8e850ede-7688-5339-a07c-302acd2aaf8d"\nversion = "1.64.0+1"\n\n[[deps.p7zip_jll]]\ndeps = ["Artifacts", "CompilerSupportLibraries_jll", "Libdl"]\nuuid = "3f19e933-33d8-53b3-aaab-bd5110c3b7a0"\nversion = "17.7.0+0"\n'
 };
@@ -909,6 +910,15 @@ async function resolveVersion(bin, channel, run) {
   }
   return { command: match.File, args: match.Args ?? [], version: match.Version };
 }
+async function resolveJulia(channel, run) {
+  const juliaup = await detectJuliaup(run);
+  if (juliaup.found && juliaup.path) return resolveVersion(juliaup.path, channel, run);
+  const julia = await detectJulia(run);
+  if (julia.found && julia.path && julia.version === channel) {
+    return { command: julia.path, args: [], version: julia.version };
+  }
+  throw new Error("juliaup not found. Run `mcmc setup` to install the Julia toolchain.");
+}
 function assertVersionsInstalled(channels, installed) {
   const have = new Set(installed.map((v) => v.id));
   const missing = channels.filter((c) => !have.has(c));
@@ -1267,6 +1277,7 @@ async function stopWorker(socket) {
   planSetup,
   predictData,
   removeVersion,
+  resolveJulia,
   resolveVersion,
   runDoctor,
   runFit,