@mcmcjs/julia 0.11.3 → 0.12.0

package/dist/index.js

@@ -233,7 +233,7 @@ async function runFit(spec, resolved, io) {
   return finalizeOkFit(spec, resolved, io, lastJsonLine(stdout), startedAt, elapsedMs);
 }
 
-// src/predict.ts
+// src/loglik.ts
 import { existsSync as existsSync3, readFileSync as readFileSync2, rmSync as rmSync2, writeFileSync as writeFileSync2 } from "fs";
 import { join as join4 } from "path";
 import {
@@ -241,6 +241,95 @@ import {
   parseSamples as parseSamples2,
   RUN_RECORD_SCHEMA_VERSION as RUN_RECORD_SCHEMA_VERSION2
 } from "@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 = join4(tmp, "request.json");
+  writeFileSync2(
+    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) rmSync2(tmp, { recursive: true, force: true });
+  }
+  const elapsedMs = Math.round(performance.now() - start);
+  if (code !== 0 || !existsSync3(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 {
+    parseSamples2(readFileSync2(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: RUN_RECORD_SCHEMA_VERSION2,
+    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: existsSync3(spec.modelPath) ? sha256(readFileSync2(spec.modelPath, "utf8")) : void 0,
+    data_sha256: sha256(canonicalJson2(spec.data)),
+    posterior_samples: io.samplesPath,
+    posterior_samples_sha256: existsSync3(io.samplesPath) ? sha256(readFileSync2(io.samplesPath, "utf8")) : void 0,
+    samples_file: io.outPath,
+    started_at: startedAt,
+    elapsed_ms: elapsedMs
+  };
+  writeFileSync2(`${io.outPath}.run.json`, `${JSON.stringify(record, null, 2)}
+`);
+  return {
+    status: "ok",
+    samplesFile: io.outPath,
+    runtimeRequested,
+    runtimeActual: julia,
+    elapsedMs
+  };
+}
+
+// src/predict.ts
+import { existsSync as existsSync4, readFileSync as readFileSync3, rmSync as rmSync3, writeFileSync as writeFileSync3 } from "fs";
+import { join as join5 } from "path";
+import {
+  canonicalJson as canonicalJson3,
+  parseSamples as parseSamples3,
+  RUN_RECORD_SCHEMA_VERSION as RUN_RECORD_SCHEMA_VERSION3
+} from "@mcmcjs/core";
 function predictData(spec) {
   const predict = spec.predict;
   if (!predict) throw new Error("spec has no [predict] block");
@@ -258,8 +347,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 = join4(tmp, "request.json");
-  writeFileSync2(
+  const requestPath = join5(tmp, "request.json");
+  writeFileSync3(
     requestPath,
     JSON.stringify({
       mode: "predict",
@@ -286,16 +375,16 @@ async function runPredict(spec, resolved, io) {
   try {
     ({ stdout, stderr, code } = await io.spawn(resolved.command, args));
   } finally {
-    if (ownTmp) rmSync2(tmp, { recursive: true, force: true });
+    if (ownTmp) rmSync3(tmp, { recursive: true, force: true });
   }
   const elapsedMs = Math.round(performance.now() - start);
-  if (code !== 0 || !existsSync3(io.outPath)) {
+  if (code !== 0 || !existsSync4(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 {
-    parseSamples2(readFileSync2(io.outPath, "utf8"));
+    parseSamples3(readFileSync3(io.outPath, "utf8"));
   } catch (error) {
     return {
       status: "error",
@@ -308,22 +397,22 @@ async function runPredict(spec, resolved, io) {
   const provenance = lastJsonLine(stdout);
   const julia = provenance?.julia_version;
   const record = {
-    schema_version: RUN_RECORD_SCHEMA_VERSION2,
+    schema_version: RUN_RECORD_SCHEMA_VERSION3,
     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: existsSync3(spec.modelPath) ? sha256(readFileSync2(spec.modelPath, "utf8")) : void 0,
-    data_sha256: sha256(canonicalJson2(data)),
+    model_sha256: existsSync4(spec.modelPath) ? sha256(readFileSync3(spec.modelPath, "utf8")) : void 0,
+    data_sha256: sha256(canonicalJson3(data)),
     posterior_samples: io.samplesPath,
-    posterior_samples_sha256: existsSync3(io.samplesPath) ? sha256(readFileSync2(io.samplesPath, "utf8")) : void 0,
+    posterior_samples_sha256: existsSync4(io.samplesPath) ? sha256(readFileSync3(io.samplesPath, "utf8")) : void 0,
     samples_file: io.outPath,
     started_at: startedAt,
     elapsed_ms: elapsedMs
   };
-  writeFileSync2(`${io.outPath}.run.json`, `${JSON.stringify(record, null, 2)}
+  writeFileSync3(`${io.outPath}.run.json`, `${JSON.stringify(record, null, 2)}
 `);
   return {
     status: "ok",
@@ -335,10 +424,10 @@ async function runPredict(spec, resolved, io) {
 }
 
 // src/project.ts
-import { copyFileSync, existsSync as existsSync4, mkdirSync as mkdirSync2, readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "fs";
+import { copyFileSync, existsSync as existsSync5, mkdirSync as mkdirSync2, readFileSync as readFileSync4, writeFileSync as writeFileSync4 } from "fs";
 import { homedir as homedir2 } from "os";
-import { join as join5 } from "path";
-import { canonicalJson as canonicalJson3, DEFAULT_JULIA_CHANNEL } from "@mcmcjs/core";
+import { join as join6 } from "path";
+import { canonicalJson as canonicalJson4, DEFAULT_JULIA_CHANNEL } from "@mcmcjs/core";
 import { createRunner as createRunner3 } from "@mcmcjs/engine";
 var PACKAGES = [
   "Turing",
@@ -375,19 +464,19 @@ function hasPins(pins) {
   return pins !== void 0 && Object.keys(pins).length > 0;
 }
 function managedProjectDir(version, pins) {
-  const base = process.env.XDG_DATA_HOME || join5(homedir2(), ".local", "share");
-  const root = join5(base, "mcmcjs", "julia", "env");
+  const base = process.env.XDG_DATA_HOME || join6(homedir2(), ".local", "share");
+  const root = join6(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(canonicalJson3(pins)).slice(0, 8)}`;
-  return join5(root, leaf);
+  if (hasPins(pins)) leaf += `-${sha256(canonicalJson4(pins)).slice(0, 8)}`;
+  return join6(root, leaf);
 }
 function sentinelPath(dir) {
-  return join5(dir, ".mcmcjs-packages.json");
+  return join6(dir, ".mcmcjs-packages.json");
 }
 var PROVISION_GENERATION = 1;
 function expectedSentinel(pins) {
-  return canonicalJson3({
+  return canonicalJson4({
     gen: PROVISION_GENERATION,
     packages: [...PACKAGES].sort(),
     pins: pins ?? {}
@@ -395,13 +484,13 @@ function expectedSentinel(pins) {
 }
 function provisioned(dir, pins) {
   try {
-    return readFileSync3(sentinelPath(dir), "utf8").trim() === expectedSentinel(pins);
+    return readFileSync4(sentinelPath(dir), "utf8").trim() === expectedSentinel(pins);
   } catch {
     return false;
   }
 }
 function managedProjectReady(dir = managedProjectDir(), pins) {
-  return existsSync4(join5(dir, "Project.toml")) && provisioned(dir, pins);
+  return existsSync5(join6(dir, "Project.toml")) && provisioned(dir, pins);
 }
 function packageSpecsCode(pins) {
   const specs = PACKAGES.map((name) => {
@@ -411,15 +500,15 @@ function packageSpecsCode(pins) {
   return `[${specs.join(", ")}]`;
 }
 function usesPinnedEnv(version, pins) {
-  return !hasPins(pins) && version === DEFAULT_JULIA_CHANNEL && existsSync4(pinnedEnvDir());
+  return !hasPins(pins) && version === DEFAULT_JULIA_CHANNEL && existsSync5(pinnedEnvDir());
 }
 async function ensureProject(juliaBin, run = createRunner3(30 * 6e4), dir = managedProjectDir(), pins, opts) {
   validatePins(pins);
   if (managedProjectReady(dir, pins)) return dir;
   mkdirSync2(dir, { recursive: true });
   if (usesPinnedEnv(opts?.version, pins)) {
-    copyFileSync(join5(pinnedEnvDir(), "Project.toml"), join5(dir, "Project.toml"));
-    copyFileSync(join5(pinnedEnvDir(), "Manifest.toml"), join5(dir, "Manifest.toml"));
+    copyFileSync(join6(pinnedEnvDir(), "Project.toml"), join6(dir, "Project.toml"));
+    copyFileSync(join6(pinnedEnvDir(), "Manifest.toml"), join6(dir, "Manifest.toml"));
     await run(juliaBin, [
       "--startup-file=no",
       `--project=${dir}`,
@@ -430,12 +519,12 @@ async function ensureProject(juliaBin, run = createRunner3(30 * 6e4), dir = mana
     const code = `using Pkg; Pkg.add(${packageSpecsCode(pins)}); Pkg.precompile()`;
     await run(juliaBin, ["--startup-file=no", `--project=${dir}`, "-e", code]);
   }
-  writeFileSync3(sentinelPath(dir), expectedSentinel(pins));
+  writeFileSync4(sentinelPath(dir), expectedSentinel(pins));
   return dir;
 }
 
 // src/run-matrix.ts
-import { join as join6 } from "path";
+import { join as join7 } from "path";
 async function runMatrix(spec, versions, io) {
   const entries = [];
   for (const version of versions) {
@@ -447,7 +536,7 @@ async function runMatrix(spec, versions, io) {
       const result = await runFit(versioned, resolved, {
         spawn: io.spawn,
         projectDir,
-        outPath: join6(io.outDir, `${version}.samples.json`),
+        outPath: join7(io.outDir, `${version}.samples.json`),
         dataFile: io.dataFile,
         dataSha256: io.dataSha256
       });
@@ -624,9 +713,9 @@ function assertVersionsInstalled(channels, installed) {
 
 // src/worker.ts
 import { spawn } from "child_process";
-import { mkdirSync as mkdirSync3, readdirSync, readFileSync as readFileSync4, rmdirSync, rmSync as rmSync3, statSync } from "fs";
+import { mkdirSync as mkdirSync3, readdirSync, readFileSync as readFileSync5, rmdirSync, rmSync as rmSync4, statSync } from "fs";
 import { createConnection } from "net";
-import { join as join7 } from "path";
+import { join as join8 } from "path";
 import { parseDrawBatchLine, parseProgressLine } from "@mcmcjs/engine";
 var START_WAIT_MS = 18e4;
 var CONNECT_TIMEOUT_MS = 1e3;
@@ -645,7 +734,7 @@ function workerPidPath(socket) {
 function killWorker(socket) {
   const pidPath = workerPidPath(socket);
   try {
-    const pid = Number(readFileSync4(pidPath, "utf8").trim());
+    const pid = Number(readFileSync5(pidPath, "utf8").trim());
     if (Number.isInteger(pid) && pid > 0) {
       try {
         process.kill(-pid, "SIGKILL");
@@ -655,17 +744,17 @@ function killWorker(socket) {
     }
   } catch {
   }
-  rmSync3(socket, { force: true });
-  rmSync3(pidPath, { force: true });
+  rmSync4(socket, { force: true });
+  rmSync4(pidPath, { force: true });
 }
 function workersDir() {
   const runtime = process.env.XDG_RUNTIME_DIR;
-  const dir = runtime ? join7(runtime, "mcmcjs") : join7(sharedTmpParent(), "workers");
+  const dir = runtime ? join8(runtime, "mcmcjs") : join8(sharedTmpParent(), "workers");
   mkdirSync3(dir, { recursive: true, mode: 448 });
   return dir;
 }
 function workerSocketPath(command, projectDir) {
-  return join7(workersDir(), `worker-${sha256(`${command}
+  return join8(workersDir(), `worker-${sha256(`${command}
 ${projectDir}`).slice(0, 12)}.sock`);
 }
 function connectOnce(path) {
@@ -720,7 +809,7 @@ async function ensureWorker(resolved, projectDir, notify, signal) {
   const startedHere = acquireStartLock(path);
   if (startedHere) {
     try {
-      rmSync3(path, { force: true });
+      rmSync4(path, { force: true });
       notify?.("starting the Julia worker (first use loads Turing, can take a minute)...");
       const child = spawn(
         resolved.command,
@@ -915,7 +1004,7 @@ async function listWorkers() {
   const sockets = readdirSync(dir).filter((f) => f.startsWith("worker-") && f.endsWith(".sock"));
   const statuses = [];
   for (const name of sockets) {
-    const socket = join7(dir, name);
+    const socket = join8(dir, name);
     let alive = false;
     try {
       const sock = await connectOnce(socket);
@@ -932,7 +1021,7 @@ async function stopWorker(socket) {
   try {
     sock = await connectOnce(socket);
   } catch {
-    rmSync3(socket, { force: true });
+    rmSync4(socket, { force: true });
     return "stale";
   }
   const acked = await new Promise((resolve) => {
@@ -948,7 +1037,7 @@ async function stopWorker(socket) {
   });
   sock.destroy();
   if (!acked) return "pending";
-  rmSync3(socket, { force: true });
+  rmSync4(socket, { force: true });
   return "stopped";
 }
 export {
@@ -972,6 +1061,7 @@ export {
   runDoctor,
   runFit,
   runFitAuto,
+  runLogLik,
   runMatrix,
   runPredict,
   runSetup,