@mcmcjs/julia 0.11.2 → 0.12.0

package/dist/fitlib.jl

@@ -88,6 +88,9 @@ end
 
 function build_sampler(sampler, backend)
     algorithm = get(sampler, "algorithm", "NUTS")
+    # Prior draws are iid: no warmup, no adaptation. The JuliaBUGS path samples
+    # ancestrally (sample_bugs_prior) instead of going through a sampler object.
+    algorithm == "Prior" && return Turing.Prior(), 0
     algorithm == "NUTS" || error("unsupported sampler algorithm: $algorithm")
     warmup = Int(get(sampler, "warmup", 1000))
     adapt_delta = Float64(get(sampler, "adapt_delta", 0.8))
@@ -310,7 +313,9 @@ function vnchain_to_wire(chn)
     total = nParams + length(extras)
 
     flat = Vector{Union{Float64,Nothing}}(undef, nIter * total * nChains)
-    cell(v) = v === missing ? nothing : Float64(v)
+    # JSON has no Inf/NaN; a non-finite draw (e.g. 1/sqrt(tau) under a diffuse
+    # prior) becomes null, which the samples parser reads back as NaN.
+    cell(v) = v === missing || !isfinite(v) ? nothing : Float64(v)
     for c in 1:nChains, p in 1:nParams, i in 1:nIter
         flat[i + (p - 1) * nIter + (c - 1) * nIter * total] = cell(arr[i, c, p])
     end
@@ -346,6 +351,31 @@ function sample_bugs(model, sampler, warmup, draws, chains, rng; callback = noth
     end
 end
 
+# JuliaBUGS prior sampling: each draw is one ancestral pass (evaluate!! with an
+# rng samples every unobserved stochastic node from its prior and recomputes the
+# deterministic ones; observed data stays fixed). The collected variables are the
+# model parameters plus generated quantities, the same columns a posterior fit
+# produces through gen_chains.
+function sample_bugs_prior(model, draws, chains, rng)
+    model isa JuliaBUGS.BUGSModelWithGradient && (model = model.base_model)
+    APPL = JuliaBUGS.AbstractPPL
+    vars = vcat(JuliaBUGS.model_parameters(model), JuliaBUGS.generated_quantities(model))
+    isempty(vars) && error("the model has no parameters or generated quantities to sample")
+    grab(env, vn) = (v = APPL.getvalue(env, vn); v isa AbstractArray ? copy(v) : v)
+    columns = Dict(vn => Vector{Any}(undef, draws * chains) for vn in vars)
+    for c in 1:chains, i in 1:draws
+        env, _ = APPL.evaluate!!(rng, model)
+        for vn in vars
+            columns[vn][i + (c - 1) * draws] = grab(env, vn)
+        end
+    end
+    dict = Dict{FlexiChains.ParameterOrExtra{<:VarName},Array}(
+        FlexiChains.Parameter(vn) =>
+            [columns[vn][i + (c - 1) * draws] for i in 1:draws, c in 1:chains] for vn in vars
+    )
+    return FlexiChains.FlexiChain{VarName}(draws, chains, dict)
+end
+
 # The JuliaBUGS counterpart to draw_streamer. A JuliaBUGS transition is a raw
 # AdvancedHMC.Transition whose params are an unconstrained vector, so (unlike the
 # Turing path) draws cannot be read off it directly. Per batch we rebuild a small
@@ -412,6 +442,69 @@ function bugs_draw_streamer(model, draws_per_chain::Int, batch_size::Int)
     end
 end
 
+# JuliaBUGS pointwise log-likelihood: restore each posterior draw into the
+# evaluation environment, recompute the deterministic nodes in topological
+# order, and record logpdf per observed node. Every unobserved stochastic node
+# must be covered by the posterior columns, or log p(y | theta) would not be a
+# function of the draw.
+function loglik_bugs(model, posterior)
+    model isa JuliaBUGS.BUGSModelWithGradient && (model = model.base_model)
+    APPL = JuliaBUGS.AbstractPPL
+    gd = model.graph_evaluation_data
+
+    sz = posterior["size"]
+    nIter, nCols, nChains = Int(sz[1]), Int(sz[2]), Int(sz[3])
+    flat = posterior["value_flat"]
+    col = Dict(n => i for (i, n) in enumerate(posterior["parameters"]))
+    posterior_names = Set(posterior["name_map"]["parameters"])
+    cell(i, p, c) = begin
+        v = flat[i + (p - 1) * nIter + (c - 1) * nIter * nCols]
+        v === nothing ? NaN : Float64(v)
+    end
+
+    restore = Tuple{APPL.VarName,Int}[]
+    for vn in JuliaBUGS.model_parameters(model)
+        leaves = collect(APPL.varname_leaves(vn, APPL.getvalue(model.evaluation_env, vn)))
+        found = count(l -> string(l) in posterior_names, leaves)
+        found == length(leaves) ||
+            error("the posterior samples do not cover $(vn); were they produced by fitting this spec?")
+        append!(restore, [(l, col[string(l)]) for l in leaves])
+    end
+    observed = [
+        (vn, i) for (i, vn) in enumerate(gd.sorted_nodes) if
+        gd.is_stochastic_vals[i] && gd.is_observed_vals[i]
+    ]
+    isempty(observed) && error("the model has no observed variables to compute a log-likelihood for")
+
+    pnames = string.(first.(observed))
+    n = length(pnames)
+    flat_out = Vector{Union{Float64,Nothing}}(undef, nIter * n * nChains)
+    for c in 1:nChains, i in 1:nIter
+        env = model.evaluation_env
+        for (leaf, p) in restore
+            env = JuliaBUGS.BangBang.setindex!!(env, cell(i, p, c), leaf)
+        end
+        for (k, node) in enumerate(gd.sorted_nodes)
+            if !gd.is_stochastic_vals[k]
+                env = JuliaBUGS.BangBang.setindex!!(
+                    env, gd.node_function_vals[k](env, gd.loop_vars_vals[k]), node,
+                )
+            end
+        end
+        for (k, (vn, idx)) in enumerate(observed)
+            dist = gd.node_function_vals[idx](env, gd.loop_vars_vals[idx])
+            v = logpdf(dist, APPL.getvalue(env, vn))
+            flat_out[i + (k - 1) * nIter + (c - 1) * nIter * n] = isfinite(v) ? Float64(v) : nothing
+        end
+    end
+    return Dict(
+        "size" => [nIter, n, nChains],
+        "value_flat" => flat_out,
+        "parameters" => pnames,
+        "name_map" => Dict("parameters" => pnames, "internals" => String[]),
+    )
+end
+
 # JuliaBUGS posterior prediction: condition the (target-blanked) model on the
 # posterior parameter columns, then evaluate!! ancestral-samples the remaining
 # latents once per posterior draw. No sampler or gradient runs.
@@ -479,7 +572,8 @@ function predict_bugs(model, posterior, targets, rng)
     n = length(pnames)
     flat_out = Vector{Union{Float64,Nothing}}(undef, nIter * n * nChains)
     for c in 1:nChains, p in 1:n, i in 1:nIter
-        flat_out[i + (p - 1) * nIter + (c - 1) * nIter * n] = arr[i, p, c]
+        v = arr[i, p, c]
+        flat_out[i + (p - 1) * nIter + (c - 1) * nIter * n] = isfinite(v) ? v : nothing
     end
     return Dict(
         "size" => [nIter, n, nChains],
@@ -543,7 +637,26 @@ function handle_request(request)
         modelmod = load_model_module(request["model"]["file"])
         entry = resolve_entry(modelmod, get(request["model"], "entry", nothing))
 
-        wire = if mode == "predict"
+        wire = if mode == "loglik"
+            if backend == "juliabugs"
+                model = Base.invokelatest(entry, bugs_namedtuple(request["data"]))
+                stage = "load_samples"
+                posterior = JSON.parsefile(request["samples"])
+                stage = "loglik"
+                Base.invokelatest(loglik_bugs, model, posterior)
+            else
+                data = ModelData(to_namedtuple(request["data"]))
+                model = Base.invokelatest(entry, data)
+                model = Base.invokelatest(condition_on_data, model, data)
+                stage = "load_samples"
+                chn = wire_to_vnchain(JSON.parsefile(request["samples"]), String[])
+                stage = "loglik"
+                pll = Base.invokelatest(Turing.DynamicPPL.pointwise_loglikelihoods, model, chn)
+                isempty(FlexiChains.parameters(pll)) &&
+                    error("the model has no observed variables to compute a log-likelihood for")
+                vnchain_to_wire(pll)
+            end
+        elseif mode == "predict"
             if backend == "juliabugs"
                 model = Base.invokelatest(entry, bugs_predict_namedtuple(request["data"]))
                 stage = "load_samples"
@@ -568,13 +681,17 @@ function handle_request(request)
             stage = "sample"
             if backend == "juliabugs"
                 model = Base.invokelatest(entry, data)
-                # Reconstruction reads the plain BUGSModel; entry may return a gradient wrapper.
-                base = hasproperty(model, :base_model) ? model.base_model : model
-                cb = get(request, "stream_draws", false) ?
-                    bugs_draw_streamer(base, draws, Int(get(request, "draw_batch_size", 25))) : nothing
-                chn = Base.invokelatest(
-                    sample_bugs, model, sampler, warmup, draws, chains, rng; callback = cb,
-                )
+                chn = if get(request["sampler"], "algorithm", "NUTS") == "Prior"
+                    Base.invokelatest(sample_bugs_prior, model, draws, chains, rng)
+                else
+                    # Reconstruction reads the plain BUGSModel; entry may return a gradient wrapper.
+                    base = hasproperty(model, :base_model) ? model.base_model : model
+                    cb = get(request, "stream_draws", false) ?
+                        bugs_draw_streamer(base, draws, Int(get(request, "draw_batch_size", 25))) : nothing
+                    Base.invokelatest(
+                        sample_bugs, model, sampler, warmup, draws, chains, rng; callback = cb,
+                    )
+                end
                 vnchain_to_wire(chn)
             else
                 cb = get(request, "stream_draws", false) ?

package/dist/index.cjs

@@ -40,6 +40,7 @@ __export(index_exports, {
   runDoctor: () => runDoctor,
   runFit: () => runFit,
   runFitAuto: () => runFitAuto,
+  runLogLik: () => runLogLik,
   runMatrix: () => runMatrix,
   runPredict: () => runPredict,
   runSetup: () => runSetup,
@@ -287,10 +288,95 @@ async function runFit(spec, resolved, io) {
   return finalizeOkFit(spec, resolved, io, lastJsonLine(stdout), startedAt, elapsedMs);
 }
 
-// src/predict.ts
+// src/loglik.ts
 var import_node_fs3 = require("fs");
 var import_node_path4 = require("path");
 var import_core2 = require("@mcmcjs/core");
+async function runLogLik(spec, resolved, io) {
+  const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const start = performance.now();
+  const runtimeRequested = spec.backend.version;
+  const ownTmp = io.tmpDir === void 0;
+  const tmp = io.tmpDir ?? makeRequestDir("loglik");
+  const requestPath = (0, import_node_path4.join)(tmp, "request.json");
+  (0, import_node_fs3.writeFileSync)(
+    requestPath,
+    JSON.stringify({
+      mode: "loglik",
+      schema_version: spec.schema_version,
+      backend: { id: spec.backend.id },
+      model: { file: spec.modelPath, entry: spec.model.entry },
+      data: spec.data,
+      samples: io.samplesPath,
+      seed: spec.seed,
+      out: io.outPath
+    })
+  );
+  const args = [
+    ...resolved.args,
+    "--startup-file=no",
+    `--project=${io.projectDir}`,
+    driverPath(),
+    requestPath
+  ];
+  let stdout;
+  let stderr;
+  let code;
+  try {
+    ({ stdout, stderr, code } = await io.spawn(resolved.command, args));
+  } finally {
+    if (ownTmp) (0, import_node_fs3.rmSync)(tmp, { recursive: true, force: true });
+  }
+  const elapsedMs = Math.round(performance.now() - start);
+  if (code !== 0 || !(0, import_node_fs3.existsSync)(io.outPath)) {
+    const failure = lastJsonLine(stderr);
+    const error = failure?.error ?? stderr.trim().split("\n").pop() ?? `julia exited with code ${code}`;
+    return { status: "error", runtimeRequested, elapsedMs, stage: toStage(failure?.stage), error };
+  }
+  try {
+    (0, import_core2.parseSamples)((0, import_node_fs3.readFileSync)(io.outPath, "utf8"));
+  } catch (error) {
+    return {
+      status: "error",
+      runtimeRequested,
+      elapsedMs,
+      stage: "write",
+      error: `log-likelihood file did not parse: ${error.message}`
+    };
+  }
+  const provenance = lastJsonLine(stdout);
+  const julia = provenance?.julia_version;
+  const record = {
+    schema_version: import_core2.RUN_RECORD_SCHEMA_VERSION,
+    spec_hash: spec.specHash,
+    seed: spec.seed,
+    backend: { id: spec.backend.id, runtime: spec.backend.runtime },
+    runtime: { requested: runtimeRequested, actual: julia, path: resolved.command },
+    manifest_sha256: provenance?.manifest_sha256,
+    packages: provenance?.packages,
+    model_sha256: (0, import_node_fs3.existsSync)(spec.modelPath) ? sha256((0, import_node_fs3.readFileSync)(spec.modelPath, "utf8")) : void 0,
+    data_sha256: sha256((0, import_core2.canonicalJson)(spec.data)),
+    posterior_samples: io.samplesPath,
+    posterior_samples_sha256: (0, import_node_fs3.existsSync)(io.samplesPath) ? sha256((0, import_node_fs3.readFileSync)(io.samplesPath, "utf8")) : void 0,
+    samples_file: io.outPath,
+    started_at: startedAt,
+    elapsed_ms: elapsedMs
+  };
+  (0, import_node_fs3.writeFileSync)(`${io.outPath}.run.json`, `${JSON.stringify(record, null, 2)}
+`);
+  return {
+    status: "ok",
+    samplesFile: io.outPath,
+    runtimeRequested,
+    runtimeActual: julia,
+    elapsedMs
+  };
+}
+
+// src/predict.ts
+var import_node_fs4 = require("fs");
+var import_node_path5 = require("path");
+var import_core3 = require("@mcmcjs/core");
 function predictData(spec) {
   const predict = spec.predict;
   if (!predict) throw new Error("spec has no [predict] block");
@@ -308,8 +394,8 @@ async function runPredict(spec, resolved, io) {
   const data = predictData(spec);
   const ownTmp = io.tmpDir === void 0;
   const tmp = io.tmpDir ?? makeRequestDir("predict");
-  const requestPath = (0, import_node_path4.join)(tmp, "request.json");
-  (0, import_node_fs3.writeFileSync)(
+  const requestPath = (0, import_node_path5.join)(tmp, "request.json");
+  (0, import_node_fs4.writeFileSync)(
     requestPath,
     JSON.stringify({
       mode: "predict",
@@ -336,16 +422,16 @@ async function runPredict(spec, resolved, io) {
   try {
     ({ stdout, stderr, code } = await io.spawn(resolved.command, args));
   } finally {
-    if (ownTmp) (0, import_node_fs3.rmSync)(tmp, { recursive: true, force: true });
+    if (ownTmp) (0, import_node_fs4.rmSync)(tmp, { recursive: true, force: true });
   }
   const elapsedMs = Math.round(performance.now() - start);
-  if (code !== 0 || !(0, import_node_fs3.existsSync)(io.outPath)) {
+  if (code !== 0 || !(0, import_node_fs4.existsSync)(io.outPath)) {
     const failure = lastJsonLine(stderr);
     const error = failure?.error ?? stderr.trim().split("\n").pop() ?? `julia exited with code ${code}`;
     return { status: "error", runtimeRequested, elapsedMs, stage: toStage(failure?.stage), error };
   }
   try {
-    (0, import_core2.parseSamples)((0, import_node_fs3.readFileSync)(io.outPath, "utf8"));
+    (0, import_core3.parseSamples)((0, import_node_fs4.readFileSync)(io.outPath, "utf8"));
   } catch (error) {
     return {
       status: "error",
@@ -358,22 +444,22 @@ async function runPredict(spec, resolved, io) {
   const provenance = lastJsonLine(stdout);
   const julia = provenance?.julia_version;
   const record = {
-    schema_version: import_core2.RUN_RECORD_SCHEMA_VERSION,
+    schema_version: import_core3.RUN_RECORD_SCHEMA_VERSION,
     spec_hash: spec.specHash,
     seed: spec.seed,
     backend: { id: spec.backend.id, runtime: spec.backend.runtime },
     runtime: { requested: runtimeRequested, actual: julia, path: resolved.command },
     manifest_sha256: provenance?.manifest_sha256,
     packages: provenance?.packages,
-    model_sha256: (0, import_node_fs3.existsSync)(spec.modelPath) ? sha256((0, import_node_fs3.readFileSync)(spec.modelPath, "utf8")) : void 0,
-    data_sha256: sha256((0, import_core2.canonicalJson)(data)),
+    model_sha256: (0, import_node_fs4.existsSync)(spec.modelPath) ? sha256((0, import_node_fs4.readFileSync)(spec.modelPath, "utf8")) : void 0,
+    data_sha256: sha256((0, import_core3.canonicalJson)(data)),
     posterior_samples: io.samplesPath,
-    posterior_samples_sha256: (0, import_node_fs3.existsSync)(io.samplesPath) ? sha256((0, import_node_fs3.readFileSync)(io.samplesPath, "utf8")) : void 0,
+    posterior_samples_sha256: (0, import_node_fs4.existsSync)(io.samplesPath) ? sha256((0, import_node_fs4.readFileSync)(io.samplesPath, "utf8")) : void 0,
     samples_file: io.outPath,
     started_at: startedAt,
     elapsed_ms: elapsedMs
   };
-  (0, import_node_fs3.writeFileSync)(`${io.outPath}.run.json`, `${JSON.stringify(record, null, 2)}
+  (0, import_node_fs4.writeFileSync)(`${io.outPath}.run.json`, `${JSON.stringify(record, null, 2)}
 `);
   return {
     status: "ok",
@@ -385,10 +471,10 @@ async function runPredict(spec, resolved, io) {
 }
 
 // src/project.ts
-var import_node_fs4 = require("fs");
+var import_node_fs5 = require("fs");
 var import_node_os3 = require("os");
-var import_node_path5 = require("path");
-var import_core3 = require("@mcmcjs/core");
+var import_node_path6 = require("path");
+var import_core4 = require("@mcmcjs/core");
 var import_engine3 = require("@mcmcjs/engine");
 var PACKAGES = [
   "Turing",
@@ -425,19 +511,19 @@ function hasPins(pins) {
   return pins !== void 0 && Object.keys(pins).length > 0;
 }
 function managedProjectDir(version, pins) {
-  const base = process.env.XDG_DATA_HOME || (0, import_node_path5.join)((0, import_node_os3.homedir)(), ".local", "share");
-  const root = (0, import_node_path5.join)(base, "mcmcjs", "julia", "env");
+  const base = process.env.XDG_DATA_HOME || (0, import_node_path6.join)((0, import_node_os3.homedir)(), ".local", "share");
+  const root = (0, import_node_path6.join)(base, "mcmcjs", "julia", "env");
   if (!version && !hasPins(pins)) return root;
   let leaf = (version ?? "default").replace(/[^A-Za-z0-9._-]/g, "_");
-  if (hasPins(pins)) leaf += `-${sha256((0, import_core3.canonicalJson)(pins)).slice(0, 8)}`;
-  return (0, import_node_path5.join)(root, leaf);
+  if (hasPins(pins)) leaf += `-${sha256((0, import_core4.canonicalJson)(pins)).slice(0, 8)}`;
+  return (0, import_node_path6.join)(root, leaf);
 }
 function sentinelPath(dir) {
-  return (0, import_node_path5.join)(dir, ".mcmcjs-packages.json");
+  return (0, import_node_path6.join)(dir, ".mcmcjs-packages.json");
 }
 var PROVISION_GENERATION = 1;
 function expectedSentinel(pins) {
-  return (0, import_core3.canonicalJson)({
+  return (0, import_core4.canonicalJson)({
     gen: PROVISION_GENERATION,
     packages: [...PACKAGES].sort(),
     pins: pins ?? {}
@@ -445,13 +531,13 @@ function expectedSentinel(pins) {
 }
 function provisioned(dir, pins) {
   try {
-    return (0, import_node_fs4.readFileSync)(sentinelPath(dir), "utf8").trim() === expectedSentinel(pins);
+    return (0, import_node_fs5.readFileSync)(sentinelPath(dir), "utf8").trim() === expectedSentinel(pins);
   } catch {
     return false;
   }
 }
 function managedProjectReady(dir = managedProjectDir(), pins) {
-  return (0, import_node_fs4.existsSync)((0, import_node_path5.join)(dir, "Project.toml")) && provisioned(dir, pins);
+  return (0, import_node_fs5.existsSync)((0, import_node_path6.join)(dir, "Project.toml")) && provisioned(dir, pins);
 }
 function packageSpecsCode(pins) {
   const specs = PACKAGES.map((name) => {
@@ -461,15 +547,15 @@ function packageSpecsCode(pins) {
   return `[${specs.join(", ")}]`;
 }
 function usesPinnedEnv(version, pins) {
-  return !hasPins(pins) && version === import_core3.DEFAULT_JULIA_CHANNEL && (0, import_node_fs4.existsSync)(pinnedEnvDir());
+  return !hasPins(pins) && version === import_core4.DEFAULT_JULIA_CHANNEL && (0, import_node_fs5.existsSync)(pinnedEnvDir());
 }
 async function ensureProject(juliaBin, run = (0, import_engine3.createRunner)(30 * 6e4), dir = managedProjectDir(), pins, opts) {
   validatePins(pins);
   if (managedProjectReady(dir, pins)) return dir;
-  (0, import_node_fs4.mkdirSync)(dir, { recursive: true });
+  (0, import_node_fs5.mkdirSync)(dir, { recursive: true });
   if (usesPinnedEnv(opts?.version, pins)) {
-    (0, import_node_fs4.copyFileSync)((0, import_node_path5.join)(pinnedEnvDir(), "Project.toml"), (0, import_node_path5.join)(dir, "Project.toml"));
-    (0, import_node_fs4.copyFileSync)((0, import_node_path5.join)(pinnedEnvDir(), "Manifest.toml"), (0, import_node_path5.join)(dir, "Manifest.toml"));
+    (0, import_node_fs5.copyFileSync)((0, import_node_path6.join)(pinnedEnvDir(), "Project.toml"), (0, import_node_path6.join)(dir, "Project.toml"));
+    (0, import_node_fs5.copyFileSync)((0, import_node_path6.join)(pinnedEnvDir(), "Manifest.toml"), (0, import_node_path6.join)(dir, "Manifest.toml"));
     await run(juliaBin, [
       "--startup-file=no",
       `--project=${dir}`,
@@ -480,12 +566,12 @@ async function ensureProject(juliaBin, run = (0, import_engine3.createRunner)(30
     const code = `using Pkg; Pkg.add(${packageSpecsCode(pins)}); Pkg.precompile()`;
     await run(juliaBin, ["--startup-file=no", `--project=${dir}`, "-e", code]);
   }
-  (0, import_node_fs4.writeFileSync)(sentinelPath(dir), expectedSentinel(pins));
+  (0, import_node_fs5.writeFileSync)(sentinelPath(dir), expectedSentinel(pins));
   return dir;
 }
 
 // src/run-matrix.ts
-var import_node_path6 = require("path");
+var import_node_path7 = require("path");
 async function runMatrix(spec, versions, io) {
   const entries = [];
   for (const version of versions) {
@@ -497,7 +583,7 @@ async function runMatrix(spec, versions, io) {
       const result = await runFit(versioned, resolved, {
         spawn: io.spawn,
         projectDir,
-        outPath: (0, import_node_path6.join)(io.outDir, `${version}.samples.json`),
+        outPath: (0, import_node_path7.join)(io.outDir, `${version}.samples.json`),
         dataFile: io.dataFile,
         dataSha256: io.dataSha256
       });
@@ -524,7 +610,7 @@ async function runMatrix(spec, versions, io) {
 }
 
 // src/setup.ts
-var import_core4 = require("@mcmcjs/core");
+var import_core5 = require("@mcmcjs/core");
 var JULIAUP_INSTALL_URL = "https://install.julialang.org";
 function juliaupInstallCommand(platform) {
   if (platform === "win32") {
@@ -534,20 +620,20 @@ function juliaupInstallCommand(platform) {
     command: "sh",
     args: [
       "-c",
-      `curl -fsSL ${JULIAUP_INSTALL_URL} | sh -s -- --yes --default-channel ${import_core4.DEFAULT_JULIA_CHANNEL}`
+      `curl -fsSL ${JULIAUP_INSTALL_URL} | sh -s -- --yes --default-channel ${import_core5.DEFAULT_JULIA_CHANNEL}`
     ]
   };
 }
 function planSetup(report, platform) {
-  if (report.julia.found && report.julia.version === import_core4.DEFAULT_JULIA_CHANNEL) return [];
+  if (report.julia.found && report.julia.version === import_core5.DEFAULT_JULIA_CHANNEL) return [];
   if (report.juliaup.found) {
     return [
       {
         tool: "julia",
-        label: `install the pinned Julia ${import_core4.DEFAULT_JULIA_CHANNEL} via juliaup`,
+        label: `install the pinned Julia ${import_core5.DEFAULT_JULIA_CHANNEL} via juliaup`,
         command: {
           command: report.juliaup.path ?? "juliaup",
-          args: ["add", import_core4.DEFAULT_JULIA_CHANNEL]
+          args: ["add", import_core5.DEFAULT_JULIA_CHANNEL]
         }
       }
     ];
@@ -555,7 +641,7 @@ function planSetup(report, platform) {
   return [
     {
       tool: "juliaup",
-      label: `install juliaup with the pinned Julia ${import_core4.DEFAULT_JULIA_CHANNEL}`,
+      label: `install juliaup with the pinned Julia ${import_core5.DEFAULT_JULIA_CHANNEL}`,
       command: juliaupInstallCommand(platform)
     }
   ];
@@ -674,9 +760,9 @@ function assertVersionsInstalled(channels, installed) {
 
 // src/worker.ts
 var import_node_child_process = require("child_process");
-var import_node_fs5 = require("fs");
+var import_node_fs6 = require("fs");
 var import_node_net = require("net");
-var import_node_path7 = require("path");
+var import_node_path8 = require("path");
 var import_engine4 = require("@mcmcjs/engine");
 var START_WAIT_MS = 18e4;
 var CONNECT_TIMEOUT_MS = 1e3;
@@ -695,7 +781,7 @@ function workerPidPath(socket) {
 function killWorker(socket) {
   const pidPath = workerPidPath(socket);
   try {
-    const pid = Number((0, import_node_fs5.readFileSync)(pidPath, "utf8").trim());
+    const pid = Number((0, import_node_fs6.readFileSync)(pidPath, "utf8").trim());
     if (Number.isInteger(pid) && pid > 0) {
       try {
         process.kill(-pid, "SIGKILL");
@@ -705,17 +791,17 @@ function killWorker(socket) {
     }
   } catch {
   }
-  (0, import_node_fs5.rmSync)(socket, { force: true });
-  (0, import_node_fs5.rmSync)(pidPath, { force: true });
+  (0, import_node_fs6.rmSync)(socket, { force: true });
+  (0, import_node_fs6.rmSync)(pidPath, { force: true });
 }
 function workersDir() {
   const runtime = process.env.XDG_RUNTIME_DIR;
-  const dir = runtime ? (0, import_node_path7.join)(runtime, "mcmcjs") : (0, import_node_path7.join)(sharedTmpParent(), "workers");
-  (0, import_node_fs5.mkdirSync)(dir, { recursive: true, mode: 448 });
+  const dir = runtime ? (0, import_node_path8.join)(runtime, "mcmcjs") : (0, import_node_path8.join)(sharedTmpParent(), "workers");
+  (0, import_node_fs6.mkdirSync)(dir, { recursive: true, mode: 448 });
   return dir;
 }
 function workerSocketPath(command, projectDir) {
-  return (0, import_node_path7.join)(workersDir(), `worker-${sha256(`${command}
+  return (0, import_node_path8.join)(workersDir(), `worker-${sha256(`${command}
 ${projectDir}`).slice(0, 12)}.sock`);
 }
 function connectOnce(path) {
@@ -739,13 +825,13 @@ var delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 function acquireStartLock(socketPath) {
   const lock = `${socketPath}.start`;
   try {
-    (0, import_node_fs5.mkdirSync)(lock);
+    (0, import_node_fs6.mkdirSync)(lock);
     return true;
   } catch {
     try {
-      if (Date.now() - (0, import_node_fs5.statSync)(lock).mtimeMs > START_WAIT_MS) {
-        (0, import_node_fs5.rmdirSync)(lock);
-        (0, import_node_fs5.mkdirSync)(lock);
+      if (Date.now() - (0, import_node_fs6.statSync)(lock).mtimeMs > START_WAIT_MS) {
+        (0, import_node_fs6.rmdirSync)(lock);
+        (0, import_node_fs6.mkdirSync)(lock);
         return true;
       }
     } catch {
@@ -755,7 +841,7 @@ function acquireStartLock(socketPath) {
 }
 function releaseStartLock(socketPath) {
   try {
-    (0, import_node_fs5.rmdirSync)(`${socketPath}.start`);
+    (0, import_node_fs6.rmdirSync)(`${socketPath}.start`);
   } catch {
   }
 }
@@ -770,7 +856,7 @@ async function ensureWorker(resolved, projectDir, notify, signal) {
   const startedHere = acquireStartLock(path);
   if (startedHere) {
     try {
-      (0, import_node_fs5.rmSync)(path, { force: true });
+      (0, import_node_fs6.rmSync)(path, { force: true });
       notify?.("starting the Julia worker (first use loads Turing, can take a minute)...");
       const child = (0, import_node_child_process.spawn)(
         resolved.command,
@@ -962,10 +1048,10 @@ async function runFitAuto(spec, resolved, io) {
 }
 async function listWorkers() {
   const dir = workersDir();
-  const sockets = (0, import_node_fs5.readdirSync)(dir).filter((f) => f.startsWith("worker-") && f.endsWith(".sock"));
+  const sockets = (0, import_node_fs6.readdirSync)(dir).filter((f) => f.startsWith("worker-") && f.endsWith(".sock"));
   const statuses = [];
   for (const name of sockets) {
-    const socket = (0, import_node_path7.join)(dir, name);
+    const socket = (0, import_node_path8.join)(dir, name);
     let alive = false;
     try {
       const sock = await connectOnce(socket);
@@ -982,7 +1068,7 @@ async function stopWorker(socket) {
   try {
     sock = await connectOnce(socket);
   } catch {
-    (0, import_node_fs5.rmSync)(socket, { force: true });
+    (0, import_node_fs6.rmSync)(socket, { force: true });
     return "stale";
   }
   const acked = await new Promise((resolve) => {
@@ -998,7 +1084,7 @@ async function stopWorker(socket) {
   });
   sock.destroy();
   if (!acked) return "pending";
-  (0, import_node_fs5.rmSync)(socket, { force: true });
+  (0, import_node_fs6.rmSync)(socket, { force: true });
   return "stopped";
 }
 // Annotate the CommonJS export names for ESM import in node:
@@ -1023,6 +1109,7 @@ async function stopWorker(socket) {
   runDoctor,
   runFit,
   runFitAuto,
+  runLogLik,
   runMatrix,
   runPredict,
   runSetup,