@mcmcjs/julia 0.6.1 → 0.7.1

package/dist/index.cjs

@@ -28,6 +28,7 @@ __export(index_exports, {
   gcVersions: () => gcVersions,
   juliaEngine: () => juliaEngine,
   juliaupInstallCommand: () => juliaupInstallCommand,
+  killWorker: () => killWorker,
   listVersions: () => listVersions,
   listWorkers: () => listWorkers,
   managedProjectDir: () => managedProjectDir,
@@ -110,12 +111,13 @@ var juliaEngine = {
 };
 
 // src/fit.ts
-var import_node_fs = require("fs");
+var import_node_fs2 = require("fs");
 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_fs = require("fs");
 var import_node_os2 = require("os");
 var import_node_path2 = require("path");
 var import_node_url = require("url");
@@ -123,11 +125,19 @@ function sharedTmpParent() {
   const uid = typeof process.getuid === "function" ? `-${process.getuid()}` : "";
   return (0, import_node_path2.join)((0, import_node_os2.tmpdir)(), `mcmcjs${uid}`);
 }
+function driverFile(name) {
+  const here = (0, import_node_path2.dirname)((0, import_node_url.fileURLToPath)(importMetaUrl));
+  const beside = (0, import_node_path2.join)(here, name);
+  return (0, import_node_fs.existsSync)(beside) ? beside : (0, import_node_path2.join)(here, "driver", name);
+}
 function driverPath() {
-  return (0, import_node_path2.join)((0, import_node_path2.dirname)((0, import_node_url.fileURLToPath)(importMetaUrl)), "driver.jl");
+  return driverFile("driver.jl");
 }
 function workerPath() {
-  return (0, import_node_path2.join)((0, import_node_path2.dirname)((0, import_node_url.fileURLToPath)(importMetaUrl)), "worker.jl");
+  return driverFile("worker.jl");
+}
+function pinnedEnvDir() {
+  return (0, import_node_path2.join)((0, import_node_path2.dirname)((0, import_node_url.fileURLToPath)(importMetaUrl)), "julia-env");
 }
 function sha256(text) {
   return (0, import_node_crypto.createHash)("sha256").update(text).digest("hex");
@@ -160,10 +170,10 @@ function toStage(value) {
 // src/fit.ts
 function makeRequestDir(kind) {
   const parent = sharedTmpParent();
-  (0, import_node_fs.mkdirSync)(parent, { recursive: true });
-  return (0, import_node_fs.mkdtempSync)((0, import_node_path3.join)(parent, `${kind}-`));
+  (0, import_node_fs2.mkdirSync)(parent, { recursive: true });
+  return (0, import_node_fs2.mkdtempSync)((0, import_node_path3.join)(parent, `${kind}-`));
 }
-function fitRequest(spec, outPath) {
+function fitRequest(spec, outPath, opts) {
   return {
     schema_version: spec.schema_version,
     backend: { id: spec.backend.id },
@@ -171,12 +181,13 @@ function fitRequest(spec, outPath) {
     data: spec.data,
     sampler: spec.sampler,
     seed: spec.seed,
-    out: outPath
+    out: outPath,
+    ...opts?.streamDraws ? { stream_draws: true } : {}
   };
 }
 function finalizeOkFit(spec, resolved, io, provenance, startedAt, elapsedMs) {
   const runtimeRequested = spec.backend.version;
-  if (!(0, import_node_fs.existsSync)(io.outPath)) {
+  if (!(0, import_node_fs2.existsSync)(io.outPath)) {
     return {
       status: "error",
       runtimeRequested,
@@ -186,7 +197,7 @@ function finalizeOkFit(spec, resolved, io, provenance, startedAt, elapsedMs) {
     };
   }
   try {
-    (0, import_core.parseSamples)((0, import_node_fs.readFileSync)(io.outPath, "utf8"));
+    (0, import_core.parseSamples)((0, import_node_fs2.readFileSync)(io.outPath, "utf8"));
   } catch (error) {
     return {
       status: "error",
@@ -205,14 +216,14 @@ function finalizeOkFit(spec, resolved, io, provenance, startedAt, elapsedMs) {
     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,
+    model_sha256: (0, import_node_fs2.existsSync)(spec.modelPath) ? sha256((0, import_node_fs2.readFileSync)(spec.modelPath, "utf8")) : void 0,
     data_sha256: io.dataSha256 ?? sha256((0, import_core.canonicalJson)(spec.data)),
     ...io.dataFile ? { data_file: io.dataFile } : {},
     samples_file: io.outPath,
     started_at: startedAt,
     elapsed_ms: elapsedMs
   };
-  (0, import_node_fs.writeFileSync)(io.recordPath ?? `${io.outPath}.run.json`, `${JSON.stringify(record, null, 2)}
+  (0, import_node_fs2.writeFileSync)(io.recordPath ?? `${io.outPath}.run.json`, `${JSON.stringify(record, null, 2)}
 `);
   return {
     status: "ok",
@@ -226,10 +237,16 @@ async function runFit(spec, resolved, io) {
   const startedAt = (/* @__PURE__ */ new Date()).toISOString();
   const start = performance.now();
   const runtimeRequested = spec.backend.version;
+  if (io.signal?.aborted) {
+    return { status: "cancelled", runtimeRequested, elapsedMs: 0 };
+  }
   const ownTmp = io.tmpDir === void 0;
   const tmp = io.tmpDir ?? makeRequestDir("fit");
   const requestPath = (0, import_node_path3.join)(tmp, "request.json");
-  (0, import_node_fs.writeFileSync)(requestPath, JSON.stringify(fitRequest(spec, io.outPath)));
+  (0, import_node_fs2.writeFileSync)(
+    requestPath,
+    JSON.stringify(fitRequest(spec, io.outPath, { streamDraws: io.onDraws !== void 0 }))
+  );
   const args = [
     ...resolved.args,
     "--startup-file=no",
@@ -240,15 +257,21 @@ async function runFit(spec, resolved, io) {
   let stdout;
   let stderr;
   let code;
+  let cancelled;
   try {
-    ({ stdout, stderr, code } = await io.spawn(resolved.command, args, {
-      onProgress: io.onProgress
+    ({ stdout, stderr, code, cancelled } = await io.spawn(resolved.command, args, {
+      onProgress: io.onProgress,
+      onDraws: io.onDraws,
+      signal: io.signal
     }));
   } finally {
-    if (ownTmp) (0, import_node_fs.rmSync)(tmp, { recursive: true, force: true });
+    if (ownTmp) (0, import_node_fs2.rmSync)(tmp, { recursive: true, force: true });
   }
   const elapsedMs = Math.round(performance.now() - start);
-  if (code !== 0 || !(0, import_node_fs.existsSync)(io.outPath)) {
+  if (cancelled) {
+    return { status: "cancelled", runtimeRequested, elapsedMs };
+  }
+  if (code !== 0 || !(0, import_node_fs2.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}`;
@@ -258,7 +281,7 @@ async function runFit(spec, resolved, io) {
 }
 
 // src/predict.ts
-var import_node_fs2 = require("fs");
+var import_node_fs3 = require("fs");
 var import_node_path4 = require("path");
 var import_core2 = require("@mcmcjs/core");
 function predictData(spec) {
@@ -279,7 +302,7 @@ async function runPredict(spec, resolved, io) {
   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_fs2.writeFileSync)(
+  (0, import_node_fs3.writeFileSync)(
     requestPath,
     JSON.stringify({
       mode: "predict",
@@ -306,16 +329,16 @@ async function runPredict(spec, resolved, io) {
   try {
     ({ stdout, stderr, code } = await io.spawn(resolved.command, args));
   } finally {
-    if (ownTmp) (0, import_node_fs2.rmSync)(tmp, { recursive: true, force: true });
+    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_fs2.existsSync)(io.outPath)) {
+  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_fs2.readFileSync)(io.outPath, "utf8"));
+    (0, import_core2.parseSamples)((0, import_node_fs3.readFileSync)(io.outPath, "utf8"));
   } catch (error) {
     return {
       status: "error",
@@ -335,15 +358,15 @@ async function runPredict(spec, resolved, io) {
     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,
+    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)),
     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,
+    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_fs2.writeFileSync)(`${io.outPath}.run.json`, `${JSON.stringify(record, null, 2)}
+  (0, import_node_fs3.writeFileSync)(`${io.outPath}.run.json`, `${JSON.stringify(record, null, 2)}
 `);
   return {
     status: "ok",
@@ -355,7 +378,7 @@ async function runPredict(spec, resolved, io) {
 }
 
 // src/project.ts
-var import_node_fs3 = require("fs");
+var import_node_fs4 = require("fs");
 var import_node_os3 = require("os");
 var import_node_path5 = require("path");
 var import_core3 = require("@mcmcjs/core");
@@ -403,18 +426,23 @@ function managedProjectDir(version, pins) {
 function sentinelPath(dir) {
   return (0, import_node_path5.join)(dir, ".mcmcjs-packages.json");
 }
+var PROVISION_GENERATION = 1;
 function expectedSentinel(pins) {
-  return (0, import_core3.canonicalJson)({ packages: [...PACKAGES].sort(), pins: pins ?? {} });
+  return (0, import_core3.canonicalJson)({
+    gen: PROVISION_GENERATION,
+    packages: [...PACKAGES].sort(),
+    pins: pins ?? {}
+  });
 }
 function provisioned(dir, pins) {
   try {
-    return (0, import_node_fs3.readFileSync)(sentinelPath(dir), "utf8").trim() === expectedSentinel(pins);
+    return (0, import_node_fs4.readFileSync)(sentinelPath(dir), "utf8").trim() === expectedSentinel(pins);
   } catch {
     return false;
   }
 }
 function managedProjectReady(dir = managedProjectDir(), pins) {
-  return (0, import_node_fs3.existsSync)((0, import_node_path5.join)(dir, "Project.toml")) && provisioned(dir, pins);
+  return (0, import_node_fs4.existsSync)((0, import_node_path5.join)(dir, "Project.toml")) && provisioned(dir, pins);
 }
 function packageSpecsCode(pins) {
   const specs = PACKAGES.map((name) => {
@@ -423,13 +451,27 @@ function packageSpecsCode(pins) {
   });
   return `[${specs.join(", ")}]`;
 }
-async function ensureProject(juliaBin, run = (0, import_engine3.createRunner)(30 * 6e4), dir = managedProjectDir(), pins) {
+function usesPinnedEnv(version, pins) {
+  return !hasPins(pins) && version === import_core3.DEFAULT_JULIA_CHANNEL && (0, import_node_fs4.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_fs3.mkdirSync)(dir, { recursive: true });
-  const code = `using Pkg; Pkg.add(${packageSpecsCode(pins)}); Pkg.precompile()`;
-  await run(juliaBin, ["--startup-file=no", `--project=${dir}`, "-e", code]);
-  (0, import_node_fs3.writeFileSync)(sentinelPath(dir), expectedSentinel(pins));
+  (0, import_node_fs4.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"));
+    await run(juliaBin, [
+      "--startup-file=no",
+      `--project=${dir}`,
+      "-e",
+      "using Pkg; Pkg.instantiate(); Pkg.precompile()"
+    ]);
+  } else {
+    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));
   return dir;
 }
 
@@ -463,6 +505,7 @@ async function runMatrix(spec, versions, io) {
       entry = { version, status: "error", elapsedMs: 0, error: error.message };
     }
     entries.push(entry);
+    if (entry.status === "cancelled") break;
     if (entry.status === "error" && !io.keepGoing) break;
   }
   return {
@@ -472,28 +515,38 @@ async function runMatrix(spec, versions, io) {
 }
 
 // src/setup.ts
+var import_core4 = require("@mcmcjs/core");
 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`] };
+  return {
+    command: "sh",
+    args: [
+      "-c",
+      `curl -fsSL ${JULIAUP_INSTALL_URL} | sh -s -- --yes --default-channel ${import_core4.DEFAULT_JULIA_CHANNEL}`
+    ]
+  };
 }
 function planSetup(report, platform) {
-  if (report.julia.found) return [];
+  if (report.julia.found && report.julia.version === import_core4.DEFAULT_JULIA_CHANNEL) 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"] }
+        label: `install the pinned Julia ${import_core4.DEFAULT_JULIA_CHANNEL} via juliaup`,
+        command: {
+          command: report.juliaup.path ?? "juliaup",
+          args: ["add", import_core4.DEFAULT_JULIA_CHANNEL]
+        }
       }
     ];
   }
   return [
     {
       tool: "juliaup",
-      label: "install juliaup (this also installs Julia)",
+      label: `install juliaup with the pinned Julia ${import_core4.DEFAULT_JULIA_CHANNEL}`,
       command: juliaupInstallCommand(platform)
     }
   ];
@@ -506,8 +559,8 @@ async function runSetup(options = {}) {
     dryRun = false
   } = options;
   const before = await runDoctor(runner);
-  if (before.ready) return { ...before, steps: [] };
   const plan = planSetup(before, platform);
+  if (plan.length === 0) return { ...before, steps: [] };
   if (dryRun) {
     return {
       ...before,
@@ -612,7 +665,7 @@ function assertVersionsInstalled(channels, installed) {
 
 // src/worker.ts
 var import_node_child_process = require("child_process");
-var import_node_fs4 = require("fs");
+var import_node_fs5 = require("fs");
 var import_node_net = require("net");
 var import_node_path7 = require("path");
 var import_engine4 = require("@mcmcjs/engine");
@@ -625,10 +678,31 @@ function fitInactivityTimeoutMs() {
 }
 var WorkerTimeoutError = class extends Error {
 };
+var FitCancelledError = class extends Error {
+};
+function workerPidPath(socket) {
+  return `${socket}.pid`;
+}
+function killWorker(socket) {
+  const pidPath = workerPidPath(socket);
+  try {
+    const pid = Number((0, import_node_fs5.readFileSync)(pidPath, "utf8").trim());
+    if (Number.isInteger(pid) && pid > 0) {
+      try {
+        process.kill(-pid, "SIGKILL");
+      } catch {
+        process.kill(pid, "SIGKILL");
+      }
+    }
+  } catch {
+  }
+  (0, import_node_fs5.rmSync)(socket, { force: true });
+  (0, import_node_fs5.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_fs4.mkdirSync)(dir, { recursive: true, mode: 448 });
+  (0, import_node_fs5.mkdirSync)(dir, { recursive: true, mode: 448 });
   return dir;
 }
 function workerSocketPath(command, projectDir) {
@@ -656,13 +730,13 @@ var delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 function acquireStartLock(socketPath) {
   const lock = `${socketPath}.start`;
   try {
-    (0, import_node_fs4.mkdirSync)(lock);
+    (0, import_node_fs5.mkdirSync)(lock);
     return true;
   } catch {
     try {
-      if (Date.now() - (0, import_node_fs4.statSync)(lock).mtimeMs > START_WAIT_MS) {
-        (0, import_node_fs4.rmdirSync)(lock);
-        (0, import_node_fs4.mkdirSync)(lock);
+      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);
         return true;
       }
     } catch {
@@ -672,21 +746,22 @@ function acquireStartLock(socketPath) {
 }
 function releaseStartLock(socketPath) {
   try {
-    (0, import_node_fs4.rmdirSync)(`${socketPath}.start`);
+    (0, import_node_fs5.rmdirSync)(`${socketPath}.start`);
   } catch {
   }
 }
-async function ensureWorker(resolved, projectDir, notify) {
+async function ensureWorker(resolved, projectDir, notify, signal) {
   const path = workerSocketPath(resolved.command, projectDir);
   try {
     return await connectOnce(path);
   } catch {
   }
+  if (signal?.aborted) throw new FitCancelledError();
   let spawnFailure;
   const startedHere = acquireStartLock(path);
   if (startedHere) {
     try {
-      (0, import_node_fs4.rmSync)(path, { force: true });
+      (0, import_node_fs5.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,
@@ -710,6 +785,7 @@ async function ensureWorker(resolved, projectDir, notify) {
   try {
     const deadline = Date.now() + START_WAIT_MS;
     for (; ; ) {
+      if (signal?.aborted) throw new FitCancelledError();
       if (spawnFailure) throw spawnFailure;
       try {
         return await connectOnce(path);
@@ -722,16 +798,27 @@ async function ensureWorker(resolved, projectDir, notify) {
     if (startedHere) releaseStartLock(path);
   }
 }
-function readWorkerResponse(sock, onProgress, inactivityMs = fitInactivityTimeoutMs()) {
+function readWorkerResponse(sock, onProgress, onDraws, signal, inactivityMs = fitInactivityTimeoutMs()) {
   return new Promise((resolve, reject) => {
     let pending = "";
     let settled = false;
+    const onAbort = () => {
+      settle(() => {
+        sock.destroy();
+        reject(new FitCancelledError());
+      });
+    };
     const settle = (fn) => {
       if (settled) return;
       settled = true;
       sock.setTimeout(0);
+      signal?.removeEventListener("abort", onAbort);
       fn();
     };
+    if (signal) {
+      if (signal.aborted) onAbort();
+      else signal.addEventListener("abort", onAbort, { once: true });
+    }
     sock.setTimeout(inactivityMs, () => {
       const error = new WorkerTimeoutError(
         `the worker sent nothing for ${Math.round(inactivityMs / 6e4)} minutes`
@@ -754,6 +841,11 @@ function readWorkerResponse(sock, onProgress, inactivityMs = fitInactivityTimeou
           onProgress?.(progress);
           continue;
         }
+        const batch = (0, import_engine4.parseDrawBatchLine)(line);
+        if (batch) {
+          onDraws?.(batch);
+          continue;
+        }
         try {
           const doc = JSON.parse(line);
           settle(() => {
@@ -772,10 +864,48 @@ function readWorkerResponse(sock, onProgress, inactivityMs = fitInactivityTimeou
 async function runFitViaWorker(spec, resolved, io) {
   const startedAt = (/* @__PURE__ */ new Date()).toISOString();
   const start = performance.now();
-  const sock = await ensureWorker(resolved, io.projectDir, io.notify);
-  sock.write(`${JSON.stringify(fitRequest(spec, io.outPath))}
-`);
-  const final = await readWorkerResponse(sock, io.onProgress);
+  if (io.signal?.aborted) {
+    return { status: "cancelled", runtimeRequested: spec.backend.version, elapsedMs: 0 };
+  }
+  let sock;
+  try {
+    sock = await ensureWorker(resolved, io.projectDir, io.notify, io.signal);
+  } catch (error) {
+    if (error instanceof FitCancelledError) {
+      return {
+        status: "cancelled",
+        runtimeRequested: spec.backend.version,
+        elapsedMs: Math.round(performance.now() - start)
+      };
+    }
+    throw error;
+  }
+  if (io.signal?.aborted) {
+    sock.destroy();
+    return {
+      status: "cancelled",
+      runtimeRequested: spec.backend.version,
+      elapsedMs: Math.round(performance.now() - start)
+    };
+  }
+  sock.write(
+    `${JSON.stringify(fitRequest(spec, io.outPath, { streamDraws: io.onDraws !== void 0 }))}
+`
+  );
+  let final;
+  try {
+    final = await readWorkerResponse(sock, io.onProgress, io.onDraws, io.signal);
+  } catch (error) {
+    if (error instanceof FitCancelledError) {
+      killWorker(workerSocketPath(resolved.command, io.projectDir));
+      return {
+        status: "cancelled",
+        runtimeRequested: spec.backend.version,
+        elapsedMs: Math.round(performance.now() - start)
+      };
+    }
+    throw error;
+  }
   const elapsedMs = Math.round(performance.now() - start);
   if (final.ok !== true) {
     if (final.stage === "worker") throw new Error(String(final.error ?? "worker error"));
@@ -797,6 +927,9 @@ async function runFitViaWorker(spec, resolved, io) {
   );
 }
 async function runFitAuto(spec, resolved, io) {
+  if (io.signal?.aborted) {
+    return { status: "cancelled", runtimeRequested: spec.backend.version, elapsedMs: 0 };
+  }
   if (io.daemon && process.platform !== "win32") {
     const start = performance.now();
     try {
@@ -820,7 +953,7 @@ async function runFitAuto(spec, resolved, io) {
 }
 async function listWorkers() {
   const dir = workersDir();
-  const sockets = (0, import_node_fs4.readdirSync)(dir).filter((f) => f.startsWith("worker-") && f.endsWith(".sock"));
+  const sockets = (0, import_node_fs5.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);
@@ -840,7 +973,7 @@ async function stopWorker(socket) {
   try {
     sock = await connectOnce(socket);
   } catch {
-    (0, import_node_fs4.rmSync)(socket, { force: true });
+    (0, import_node_fs5.rmSync)(socket, { force: true });
     return "stale";
   }
   const acked = await new Promise((resolve) => {
@@ -856,7 +989,7 @@ async function stopWorker(socket) {
   });
   sock.destroy();
   if (!acked) return "pending";
-  (0, import_node_fs4.rmSync)(socket, { force: true });
+  (0, import_node_fs5.rmSync)(socket, { force: true });
   return "stopped";
 }
 // Annotate the CommonJS export names for ESM import in node:
@@ -869,6 +1002,7 @@ async function stopWorker(socket) {
   gcVersions,
   juliaEngine,
   juliaupInstallCommand,
+  killWorker,
   listVersions,
   listWorkers,
   managedProjectDir,