@mcmcjs/julia 0.11.3 → 0.13.0

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",
@@ -399,6 +485,7 @@ var PACKAGES = [
   "AdvancedHMC",
   "ForwardDiff",
   "Mooncake",
+  "ReverseDiff",
   "JSON",
   "StableRNGs",
   "StatsFuns"
@@ -425,19 +512,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 +532,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 +548,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 +567,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 +584,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 +611,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 +621,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 +642,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 +761,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 +782,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 +792,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 +826,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 +842,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 +857,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 +1049,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 +1069,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 +1085,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 +1110,7 @@ async function stopWorker(socket) {
   runDoctor,
   runFit,
   runFitAuto,
+  runLogLik,
   runMatrix,
   runPredict,
   runSetup,