@mcmcjs/julia 0.1.0 → 0.3.0

package/dist/driver.jl

@@ -0,0 +1,186 @@
+# MCMC.js fit driver. Reads a run-request JSON, runs the spec's backend (Turing or
+# JuliaBUGS), and writes the draws as MCMCChains-JSON (the @mcmcjs/core samples
+# artifact). On success a single line of provenance JSON is printed to stdout;
+# failures print one-line JSON to stderr ({error, stage}) and exit nonzero. This is
+# the only place that touches the backend chain types, so a chain-type change is
+# contained here.
+using JSON
+using Random
+using StableRNGs
+using Turing
+using Turing: VarName
+using MCMCChains
+using SHA
+using Pkg
+# Imported (not `using`) so they do not pull `@model` etc. into Main and clash
+# with Turing's exports, which would break Turing model files on include.
+import JuliaBUGS
+import AdvancedHMC
+import ForwardDiff
+
+function build_sampler(sampler, backend)
+    algorithm = get(sampler, "algorithm", "NUTS")
+    algorithm == "NUTS" || error("unsupported sampler algorithm: $algorithm")
+    warmup = Int(get(sampler, "warmup", 1000))
+    adapt_delta = Float64(get(sampler, "adapt_delta", 0.8))
+    nuts = backend == "juliabugs" ? AdvancedHMC.NUTS(adapt_delta) : Turing.NUTS(warmup, adapt_delta)
+    return nuts, warmup
+end
+
+to_namedtuple(data) = (; (Symbol(k) => v for (k, v) in data)...)
+
+# JuliaBUGS requires dense arrays with a concrete numeric eltype, but JSON parses
+# them as Vector{Any} (and nested arrays as vectors of vectors). narrow promotes a
+# numeric array to a concrete eltype and stacks equal-sized nested arrays into a
+# dense array; an empty array becomes Float64[].
+function narrow(v::AbstractVector)
+    isempty(v) && return Float64[]
+    elems = [narrow(x) for x in v]
+    if all(e -> e isa AbstractArray, elems) && allequal(size.(elems))
+        return stack(elems; dims = 1)
+    end
+    return eltype(elems) <: Real && !isconcretetype(eltype(elems)) ? float.(elems) : elems
+end
+narrow(x) = x
+bugs_namedtuple(data) = (; (Symbol(k) => narrow(v) for (k, v) in data)...)
+
+# JSON null arrives as `nothing`; map it to `missing` so a blanked outcome becomes
+# a sampling (predictive) statement in the model.
+to_missing(x) = x === nothing ? missing : (x isa AbstractVector ? map(to_missing, x) : x)
+predict_namedtuple(data) = (; (Symbol(k) => to_missing(v) for (k, v) in data)...)
+
+# Rebuild a posterior Chains (latents only) from our MCMCChains-JSON wire object so
+# it can feed Turing.predict. The varname_to_symbol map is required for VarName
+# indexing; target outcome columns are excluded.
+function chains_from_wire(wire, targets)
+    sz = wire["size"]
+    nIter, nParams, nChains = Int(sz[1]), Int(sz[2]), Int(sz[3])
+    flat = wire["value_flat"]
+    allnames = wire["parameters"]
+    is_target(n) = any(t -> n == t || startswith(n, t * "["), targets)
+    keep = [n for n in wire["name_map"]["parameters"] if !is_target(n)]
+    index = Dict(n => i for (i, n) in enumerate(allnames))
+    arr = Array{Float64,3}(undef, nIter, length(keep), nChains)
+    for (newp, n) in enumerate(keep)
+        p = index[n]
+        for c in 1:nChains, i in 1:nIter
+            v = flat[i + (p - 1) * nIter + (c - 1) * nIter * nParams]
+            arr[i, newp, c] = v === nothing ? NaN : Float64(v)
+        end
+    end
+    syms = Symbol.(keep)
+    vmap = Dict{VarName,Symbol}(eval(:(Turing.@varname($(Meta.parse(n))))) => Symbol(n) for n in keep)
+    return MCMCChains.Chains(arr, syms, Dict(:parameters => syms); info = (; varname_to_symbol = vmap))
+end
+
+# Build the model and sample in one call so both run in the latest world age:
+# the model methods are defined by `include` at runtime, so a plain call from
+# this (older) world would fail with "method too new". invokelatest fixes that.
+function build_and_sample(entry, data, sampler, draws, chains, rng)
+    model = entry(data)
+    # Sample into Turing's default chain type (a FlexiChain), then convert to
+    # MCMCChains for serialization.
+    chn = sample(rng, model, sampler, MCMCSerial(), draws, chains; progress = false)
+    return MCMCChains.Chains(chn)
+end
+
+# JuliaBUGS compiles the model at runtime, so building and sampling must run in
+# separate latest-world frames; merging them reintroduces a world-age error. The
+# result is already an MCMCChains.Chains, so it is not re-wrapped.
+function sample_bugs(model, sampler, warmup, draws, chains, rng)
+    return JuliaBUGS.AbstractMCMC.sample(
+        rng, model, sampler, JuliaBUGS.AbstractMCMC.MCMCSerial(), draws, chains;
+        chain_type = MCMCChains.Chains, n_adapts = warmup, discard_initial = warmup, progress = false,
+    )
+end
+
+# Build the exact wire object parseMCMCChainsJson consumes: value_flat is indexed
+# i + p*nIter + c*nIter*nParams (column-major over [iteration, parameter, chain]).
+function chains_to_wire(chn)
+    arr = Array(chn.value)
+    nIter, nParams, nChains = size(arr)
+    flat = Vector{Union{Float64,Nothing}}(undef, nIter * nParams * nChains)
+    for c in 1:nChains, p in 1:nParams, i in 1:nIter
+        v = arr[i, p, c]
+        flat[i + (p - 1) * nIter + (c - 1) * nIter * nParams] = v === missing ? nothing : Float64(v)
+    end
+    return Dict(
+        "size" => [nIter, nParams, nChains],
+        "value_flat" => flat,
+        "parameters" => string.(names(chn)),
+        "name_map" => Dict(
+            "parameters" => string.(get(chn.name_map, :parameters, Symbol[])),
+            "internals" => string.(get(chn.name_map, :internals, Symbol[])),
+        ),
+    )
+end
+
+function provenance()
+    packages = Dict{String,String}()
+    for (_, info) in Pkg.dependencies()
+        if info.name in
+           ("Turing", "MCMCChains", "DynamicPPL", "AbstractMCMC", "JuliaBUGS", "AdvancedHMC", "ForwardDiff", "ADTypes") &&
+           info.version !== nothing
+            packages[info.name] = string(info.version)
+        end
+    end
+    manifest = joinpath(dirname(Base.active_project()), "Manifest.toml")
+    return Dict(
+        "julia_version" => string(VERSION),
+        "packages" => packages,
+        "manifest_sha256" => isfile(manifest) ? bytes2hex(sha256(read(manifest))) : "",
+    )
+end
+
+function main()
+    request = JSON.parsefile(ARGS[1])
+    out = request["out"]
+    mode = get(request, "mode", "fit")
+    backend = get(get(request, "backend", Dict()), "id", "turing")
+    stage = "compile"
+    try
+        Random.seed!(Int(request["seed"]))
+        rng = StableRNG(Int(request["seed"]))
+        include(abspath(request["model"]["file"]))
+        entry = getfield(Main, Symbol(request["model"]["entry"]))
+
+        wire = if mode == "predict"
+            backend == "turing" || error("predict is not yet supported for backend $backend")
+            model = Base.invokelatest(entry, predict_namedtuple(request["data"]))
+            stage = "load_samples"
+            rchn = chains_from_wire(JSON.parsefile(request["samples"]), request["predict"]["targets"])
+            stage = "predict"
+            pp = Base.invokelatest(predict, rng, model, rchn)
+            isempty(names(pp)) &&
+                error("no variables predicted; check that [predict].targets name unconditioned outcomes")
+            chains_to_wire(pp)
+        else
+            data = backend == "juliabugs" ? bugs_namedtuple(request["data"]) : to_namedtuple(request["data"])
+            sampler, warmup = build_sampler(request["sampler"], backend)
+            draws = Int(request["sampler"]["draws"])
+            chains = Int(get(request["sampler"], "chains", 4))
+            stage = "sample"
+            chn = if backend == "juliabugs"
+                model = Base.invokelatest(entry, data)
+                Base.invokelatest(sample_bugs, model, sampler, warmup, draws, chains, rng)
+            else
+                Base.invokelatest(build_and_sample, entry, data, sampler, draws, chains, rng)
+            end
+            chains_to_wire(chn)
+        end
+
+        stage = "write"
+        tmp = out * ".tmp"
+        open(tmp, "w") do io
+            JSON.print(io, wire)
+        end
+        mv(tmp, out; force = true)
+
+        println(JSON.json(provenance()))
+    catch err
+        println(stderr, JSON.json(Dict("error" => sprint(showerror, err), "stage" => stage)))
+        exit(1)
+    end
+end
+
+main()

package/dist/index.cjs

@@ -20,22 +20,41 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  addVersion: () => addVersion,
+  assertVersionsInstalled: () => assertVersionsInstalled,
   detectJulia: () => detectJulia,
   detectJuliaup: () => detectJuliaup,
-  runDoctor: () => runDoctor
+  ensureProject: () => ensureProject,
+  gcVersions: () => gcVersions,
+  juliaEngine: () => juliaEngine,
+  juliaupInstallCommand: () => juliaupInstallCommand,
+  listVersions: () => listVersions,
+  managedProjectDir: () => managedProjectDir,
+  managedProjectReady: () => managedProjectReady,
+  planSetup: () => planSetup,
+  predictData: () => predictData,
+  removeVersion: () => removeVersion,
+  resolveVersion: () => resolveVersion,
+  runDoctor: () => runDoctor,
+  runFit: () => runFit,
+  runMatrix: () => runMatrix,
+  runPredict: () => runPredict,
+  runSetup: () => runSetup,
+  setDefaultVersion: () => setDefaultVersion,
+  updateVersion: () => updateVersion
 });
 module.exports = __toCommonJS(index_exports);
 
+// ../../node_modules/.pnpm/tsup@8.5.1_postcss@8.5.15_typescript@6.0.3/node_modules/tsup/assets/cjs_shims.js
+var getImportMetaUrl = () => typeof document === "undefined" ? new URL(`file:${__filename}`).href : document.currentScript && document.currentScript.tagName.toUpperCase() === "SCRIPT" ? document.currentScript.src : new URL("main.js", document.baseURI).href;
+var importMetaUrl = /* @__PURE__ */ getImportMetaUrl();
+
 // src/environment.ts
-var import_node_child_process = require("child_process");
 var import_node_os = require("os");
 var import_node_path = require("path");
-var import_node_util = require("util");
-var execFileAsync = (0, import_node_util.promisify)(import_node_child_process.execFile);
-var defaultRunner = async (command, args) => {
-  const { stdout } = await execFileAsync(command, args, { timeout: 1e4 });
-  return stdout;
-};
+var import_engine = require("@mcmcjs/engine");
+var import_engine2 = require("@mcmcjs/engine");
+var defaultRunner = (0, import_engine.createRunner)();
 function candidates(binary) {
   return [(0, import_node_path.join)((0, import_node_os.homedir)(), ".juliaup", "bin", binary), binary];
 }
@@ -62,10 +81,465 @@ async function runDoctor(runner) {
   const [juliaup, julia] = await Promise.all([detectJuliaup(runner), detectJulia(runner)]);
   return { juliaup, julia, ready: julia.found };
 }
+
+// src/engine.ts
+var JULIAUP_URL = "https://github.com/JuliaLang/juliaup";
+var juliaEngine = {
+  id: "julia",
+  displayName: "Julia",
+  capabilities: { setup: true, versions: true, fit: true, predict: true },
+  async doctor(ctx) {
+    const report = await runDoctor(ctx.run);
+    return {
+      engineId: "julia",
+      ready: report.ready,
+      tools: [
+        { name: "juliaup", ...report.juliaup },
+        { name: "julia", ...report.julia }
+      ],
+      hint: report.ready ? void 0 : `Julia not found. Install it with juliaup (${JULIAUP_URL}), or run \`mcmc setup\`.`
+    };
+  }
+};
+
+// src/fit.ts
+var import_node_fs = require("fs");
+var import_node_os2 = require("os");
+var import_node_path3 = require("path");
+var import_core = require("@mcmcjs/core");
+
+// src/runner-common.ts
+var import_node_crypto = require("crypto");
+var import_node_path2 = require("path");
+var import_node_url = require("url");
+function driverPath() {
+  return (0, import_node_path2.join)((0, import_node_path2.dirname)((0, import_node_url.fileURLToPath)(importMetaUrl)), "driver.jl");
+}
+function sha256(text) {
+  return (0, import_node_crypto.createHash)("sha256").update(text).digest("hex");
+}
+function lastJsonLine(text) {
+  for (const line of text.trimEnd().split("\n").reverse()) {
+    const trimmed = line.trim();
+    if (!trimmed.startsWith("{")) continue;
+    try {
+      return JSON.parse(trimmed);
+    } catch {
+      return void 0;
+    }
+  }
+  return void 0;
+}
+var STAGES = /* @__PURE__ */ new Set([
+  "compile",
+  "sample",
+  "load_samples",
+  "predict",
+  "write",
+  "spawn"
+]);
+function toStage(value) {
+  return typeof value === "string" && STAGES.has(value) ? value : void 0;
+}
+
+// src/fit.ts
+async function runFit(spec, resolved, io) {
+  const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const start = performance.now();
+  const runtimeRequested = spec.backend.version;
+  const tmp = io.tmpDir ?? (0, import_node_fs.mkdtempSync)((0, import_node_path3.join)((0, import_node_os2.tmpdir)(), "mcmcjs-fit-"));
+  const requestPath = (0, import_node_path3.join)(tmp, "request.json");
+  (0, import_node_fs.writeFileSync)(
+    requestPath,
+    JSON.stringify({
+      schema_version: spec.schema_version,
+      backend: { id: spec.backend.id },
+      model: { file: spec.modelPath, entry: spec.model.entry },
+      data: spec.data,
+      sampler: spec.sampler,
+      seed: spec.seed,
+      out: io.outPath
+    })
+  );
+  const args = [
+    ...resolved.args,
+    "--startup-file=no",
+    `--project=${io.projectDir}`,
+    driverPath(),
+    requestPath
+  ];
+  const { stdout, stderr, code } = await io.spawn(resolved.command, args);
+  const elapsedMs = Math.round(performance.now() - start);
+  if (code !== 0 || !(0, import_node_fs.existsSync)(io.outPath)) {
+    const failure = lastJsonLine(stderr);
+    const stage = toStage(failure?.stage);
+    const error = failure?.error ?? stderr.trim().split("\n").pop() ?? `julia exited with code ${code}`;
+    return { status: "error", runtimeRequested, elapsedMs, stage, error };
+  }
+  try {
+    (0, import_core.parseSamples)((0, import_node_fs.readFileSync)(io.outPath, "utf8"));
+  } catch (error) {
+    return {
+      status: "error",
+      runtimeRequested,
+      elapsedMs,
+      stage: "write",
+      error: `samples file did not parse: ${error.message}`
+    };
+  }
+  const provenance = lastJsonLine(stdout);
+  const julia = provenance?.julia_version;
+  const record = {
+    schema_version: import_core.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_fs.existsSync)(spec.modelPath) ? sha256((0, import_node_fs.readFileSync)(spec.modelPath, "utf8")) : void 0,
+    data_sha256: sha256((0, import_core.canonicalJson)(spec.data)),
+    samples_file: io.outPath,
+    started_at: startedAt,
+    elapsed_ms: elapsedMs
+  };
+  (0, import_node_fs.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_fs2 = require("fs");
+var import_node_os3 = require("os");
+var import_node_path4 = require("path");
+var import_core2 = require("@mcmcjs/core");
+function predictData(spec) {
+  const predict = spec.predict;
+  if (!predict) throw new Error("spec has no [predict] block");
+  const data = { ...spec.data, ...predict.data ?? {} };
+  const blank = (value) => Array.isArray(value) ? value.map(blank) : null;
+  for (const target of predict.targets) {
+    data[target] = blank(data[target]);
+  }
+  return data;
+}
+async function runPredict(spec, resolved, io) {
+  const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const start = performance.now();
+  const runtimeRequested = spec.backend.version;
+  const data = predictData(spec);
+  const tmp = io.tmpDir ?? (0, import_node_fs2.mkdtempSync)((0, import_node_path4.join)((0, import_node_os3.tmpdir)(), "mcmcjs-predict-"));
+  const requestPath = (0, import_node_path4.join)(tmp, "request.json");
+  (0, import_node_fs2.writeFileSync)(
+    requestPath,
+    JSON.stringify({
+      mode: "predict",
+      schema_version: spec.schema_version,
+      backend: { id: spec.backend.id },
+      model: { file: spec.modelPath, entry: spec.model.entry },
+      data,
+      predict: { targets: spec.predict?.targets ?? [] },
+      samples: io.samplesPath,
+      seed: spec.seed,
+      out: io.outPath
+    })
+  );
+  const args = [
+    ...resolved.args,
+    "--startup-file=no",
+    `--project=${io.projectDir}`,
+    driverPath(),
+    requestPath
+  ];
+  const { stdout, stderr, code } = await io.spawn(resolved.command, args);
+  const elapsedMs = Math.round(performance.now() - start);
+  if (code !== 0 || !(0, import_node_fs2.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_fs2.readFileSync)(io.outPath, "utf8"));
+  } catch (error) {
+    return {
+      status: "error",
+      runtimeRequested,
+      elapsedMs,
+      stage: "write",
+      error: `samples 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_fs2.existsSync)(spec.modelPath) ? sha256((0, import_node_fs2.readFileSync)(spec.modelPath, "utf8")) : void 0,
+    data_sha256: sha256((0, import_core2.canonicalJson)(data)),
+    posterior_samples: io.samplesPath,
+    posterior_samples_sha256: (0, import_node_fs2.existsSync)(io.samplesPath) ? sha256((0, import_node_fs2.readFileSync)(io.samplesPath, "utf8")) : void 0,
+    samples_file: io.outPath,
+    started_at: startedAt,
+    elapsed_ms: elapsedMs
+  };
+  (0, import_node_fs2.writeFileSync)(`${io.outPath}.run.json`, `${JSON.stringify(record, null, 2)}
+`);
+  return {
+    status: "ok",
+    samplesFile: io.outPath,
+    runtimeRequested,
+    runtimeActual: julia,
+    elapsedMs
+  };
+}
+
+// src/project.ts
+var import_node_fs3 = require("fs");
+var import_node_os4 = require("os");
+var import_node_path5 = require("path");
+var import_engine3 = require("@mcmcjs/engine");
+var PACKAGES = [
+  "Turing",
+  "MCMCChains",
+  "JuliaBUGS",
+  "AdvancedHMC",
+  "ForwardDiff",
+  "JSON",
+  "StableRNGs"
+];
+function managedProjectDir() {
+  const base = process.env.XDG_DATA_HOME || (0, import_node_path5.join)((0, import_node_os4.homedir)(), ".local", "share");
+  return (0, import_node_path5.join)(base, "mcmcjs", "julia", "env");
+}
+function sentinelPath(dir) {
+  return (0, import_node_path5.join)(dir, ".mcmcjs-packages.json");
+}
+function provisioned(dir) {
+  try {
+    return (0, import_node_fs3.readFileSync)(sentinelPath(dir), "utf8").trim() === JSON.stringify([...PACKAGES].sort());
+  } catch {
+    return false;
+  }
+}
+function managedProjectReady(dir = managedProjectDir()) {
+  return (0, import_node_fs3.existsSync)((0, import_node_path5.join)(dir, "Project.toml")) && provisioned(dir);
+}
+async function ensureProject(juliaBin, run = (0, import_engine3.createRunner)(30 * 6e4), dir = managedProjectDir()) {
+  if (managedProjectReady(dir)) return dir;
+  (0, import_node_fs3.mkdirSync)(dir, { recursive: true });
+  const code = `using Pkg; Pkg.add(${JSON.stringify(PACKAGES)}); Pkg.precompile()`;
+  await run(juliaBin, ["--startup-file=no", `--project=${dir}`, "-e", code]);
+  (0, import_node_fs3.writeFileSync)(sentinelPath(dir), JSON.stringify([...PACKAGES].sort()));
+  return dir;
+}
+
+// src/run-matrix.ts
+var import_node_path6 = require("path");
+async function runMatrix(spec, versions, io) {
+  const entries = [];
+  for (const version of versions) {
+    let entry;
+    try {
+      const resolved = await io.resolve(version);
+      const versioned = { ...spec, backend: { ...spec.backend, version } };
+      const result = await runFit(versioned, resolved, {
+        spawn: io.spawn,
+        projectDir: io.projectDir,
+        outPath: (0, import_node_path6.join)(io.outDir, `${version}.samples.json`)
+      });
+      entry = {
+        version,
+        status: result.status,
+        samplesFile: result.samplesFile,
+        runtimeActual: result.runtimeActual,
+        elapsedMs: result.elapsedMs,
+        stage: result.stage,
+        error: result.error
+      };
+    } catch (error) {
+      entry = { version, status: "error", elapsedMs: 0, error: error.message };
+    }
+    entries.push(entry);
+    if (entry.status === "error" && !io.keepGoing) break;
+  }
+  return {
+    entries,
+    ok: entries.length === versions.length && entries.every((e) => e.status === "ok")
+  };
+}
+
+// src/setup.ts
+var JULIAUP_INSTALL_URL = "https://install.julialang.org";
+function juliaupInstallCommand(platform) {
+  if (platform === "win32") {
+    return null;
+  }
+  return { command: "sh", args: ["-c", `curl -fsSL ${JULIAUP_INSTALL_URL} | sh -s -- --yes`] };
+}
+function planSetup(report, platform) {
+  if (report.julia.found) return [];
+  if (report.juliaup.found) {
+    return [
+      {
+        tool: "julia",
+        label: "install the latest stable Julia via juliaup",
+        command: { command: report.juliaup.path ?? "juliaup", args: ["add", "release"] }
+      }
+    ];
+  }
+  return [
+    {
+      tool: "juliaup",
+      label: "install juliaup (this also installs Julia)",
+      command: juliaupInstallCommand(platform)
+    }
+  ];
+}
+async function runSetup(options = {}) {
+  const {
+    runner,
+    installer = (0, import_engine2.createRunner)(15 * 6e4),
+    platform = process.platform,
+    dryRun = false
+  } = options;
+  const before = await runDoctor(runner);
+  if (before.ready) return { ...before, steps: [] };
+  const plan = planSetup(before, platform);
+  if (dryRun) {
+    return {
+      ...before,
+      steps: plan.map((step) => ({ ...step, status: step.command ? "skipped" : "unsupported" }))
+    };
+  }
+  const steps = [];
+  for (const step of plan) {
+    if (!step.command) {
+      steps.push({ ...step, status: "unsupported" });
+      continue;
+    }
+    try {
+      await installer(step.command.command, step.command.args);
+      steps.push({ ...step, status: "ran" });
+    } catch (error) {
+      const detail = error instanceof Error ? error.message : String(error);
+      steps.push({ ...step, status: "failed", detail });
+    }
+  }
+  const after = await runDoctor(runner);
+  return { juliaup: after.juliaup, julia: after.julia, ready: after.ready, steps };
+}
+
+// src/versions.ts
+function parseChannel(value) {
+  const c = value;
+  if (!c || typeof c.Name !== "string" || typeof c.File !== "string") {
+    throw new Error("unexpected `juliaup api getconfig1` channel shape");
+  }
+  return {
+    Name: c.Name,
+    File: c.File,
+    Args: Array.isArray(c.Args) ? c.Args : void 0,
+    Version: typeof c.Version === "string" ? c.Version : void 0,
+    Arch: typeof c.Arch === "string" ? c.Arch : void 0
+  };
+}
+function parseGetconfig1(raw) {
+  let data;
+  try {
+    data = JSON.parse(raw);
+  } catch {
+    throw new Error("could not parse `juliaup api getconfig1` output as JSON");
+  }
+  const obj = data;
+  if (!obj || typeof obj !== "object" || !Array.isArray(obj.OtherChannels)) {
+    throw new Error("unexpected `juliaup api getconfig1` output");
+  }
+  return {
+    DefaultChannel: obj.DefaultChannel ? parseChannel(obj.DefaultChannel) : null,
+    OtherChannels: obj.OtherChannels.map(parseChannel)
+  };
+}
+function toVersion(channel, isDefault) {
+  return { id: channel.Name, version: channel.Version, path: channel.File || void 0, isDefault };
+}
+async function listVersions(bin, run) {
+  const config = parseGetconfig1(await run(bin, ["api", "getconfig1"]));
+  const versions = [];
+  if (config.DefaultChannel) versions.push(toVersion(config.DefaultChannel, true));
+  for (const channel of config.OtherChannels) versions.push(toVersion(channel, false));
+  return versions;
+}
+async function addVersion(bin, channel, opts, run) {
+  await run(bin, ["add", channel]);
+  if (opts.default) await run(bin, ["default", channel]);
+}
+async function removeVersion(bin, channel, run) {
+  await run(bin, ["remove", channel]);
+}
+async function setDefaultVersion(bin, channel, run) {
+  await run(bin, ["default", channel]);
+}
+async function updateVersion(bin, channel, run) {
+  await run(bin, channel ? ["update", channel] : ["update"]);
+}
+async function gcVersions(bin, run) {
+  await run(bin, ["gc"]);
+}
+async function resolveVersion(bin, channel, run) {
+  const config = parseGetconfig1(await run(bin, ["api", "getconfig1"]));
+  const all = config.DefaultChannel ? [config.DefaultChannel, ...config.OtherChannels] : config.OtherChannels;
+  const match = all.find((c) => c.Name === channel);
+  if (!match?.File) {
+    throw new Error(
+      `Julia version "${channel}" is not installed. Add it with: mcmc julia version add ${channel}`
+    );
+  }
+  return { command: match.File, args: match.Args ?? [] };
+}
+function assertVersionsInstalled(channels, installed) {
+  const have = new Set(installed.map((v) => v.id));
+  const missing = channels.filter((c) => !have.has(c));
+  if (missing.length > 0) {
+    const fixes = missing.map((m) => `mcmc julia version add ${m}`).join("; ");
+    throw new Error(
+      `Julia version(s) not installed: ${missing.join(", ")}. Install with: ${fixes}`
+    );
+  }
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  addVersion,
+  assertVersionsInstalled,
   detectJulia,
   detectJuliaup,
-  runDoctor
+  ensureProject,
+  gcVersions,
+  juliaEngine,
+  juliaupInstallCommand,
+  listVersions,
+  managedProjectDir,
+  managedProjectReady,
+  planSetup,
+  predictData,
+  removeVersion,
+  resolveVersion,
+  runDoctor,
+  runFit,
+  runMatrix,
+  runPredict,
+  runSetup,
+  setDefaultVersion,
+  updateVersion
 });
 //# sourceMappingURL=index.cjs.map