turbollm 1.2.1 → 1.3.2

package/dist/cli.js

@@ -1,10 +1,10 @@
 #!/usr/bin/env node
 
 // src/cli.ts
-import { spawn as spawn4 } from "child_process";
-import { openSync as openSync3, readFileSync as readFileSync9 } from "fs";
+import { spawn as spawn5 } from "child_process";
+import { openSync as openSync3, readFileSync as readFileSync10 } from "fs";
 import { serve } from "@hono/node-server";
-import { dirname as dirname8, join as join19 } from "path";
+import { dirname as dirname9, join as join21 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/config/config.ts
@@ -90,7 +90,8 @@ function defaultConfig() {
     comfyui: { enabled: false, gatePath: "", url: "", reverseGate: false, cachePersist: false },
     gateway: { autoSwap: true, keepN: 1 },
     tools: {},
-    mcp: { servers: [] }
+    mcp: { servers: [] },
+    build: { toolchainDirs: [] }
   };
 }
 var ConfigStore = class _ConfigStore {
@@ -254,6 +255,10 @@ function normalize(c) {
   c.mcp = {
     servers: Array.isArray(mc.servers) ? mc.servers.filter((s) => typeof s === "object" && s !== null && typeof s.id === "string" && typeof s.name === "string" && (s.transport === "stdio" || s.transport === "sse")) : []
   };
+  const bd = c.build ?? {};
+  c.build = {
+    toolchainDirs: Array.isArray(bd.toolchainDirs) ? bd.toolchainDirs.filter((p) => typeof p === "string" && p.trim() !== "").map((p) => p.trim()) : []
+  };
   c.telemetry.level = normalizeTelemetryLevel(c.telemetry.level);
   for (const e of c.engines) {
     e.capabilities ??= { kvTypes: [], flags: [] };
@@ -284,6 +289,9 @@ function validate(c) {
   if (c.comfyui.url && !/^https?:\/\//i.test(c.comfyui.url)) {
     throw new ValueError("comfyui.url", "must be an http(s):// origin (e.g. http://127.0.0.1:8188)");
   }
+  for (const dir of c.build.toolchainDirs) {
+    if (!isAbsolutePath(dir)) throw new ValueError("build.toolchainDirs", "toolchain directories must be absolute paths");
+  }
 }
 function isAbsolutePath(p) {
   return /^([a-zA-Z]:[\\/]|[\\/])/.test(p);
@@ -311,12 +319,19 @@ import { promisify as promisify2 } from "util";
 
 // src/engines/download.ts
 import { createWriteStream, existsSync as existsSync2, mkdirSync as mkdirSync2, readdirSync, rmSync } from "fs";
-import { execFile } from "child_process";
+import { execFile, execFileSync } from "child_process";
 import { join as join2 } from "path";
 import { Readable } from "stream";
 import { pipeline } from "stream/promises";
 import { promisify } from "util";
 var execFileP = promisify(execFile);
+function stripMacOsQuarantine(dir) {
+  if (process.platform !== "darwin") return;
+  try {
+    execFileSync("xattr", ["-r", "-d", "com.apple.quarantine", dir]);
+  } catch {
+  }
+}
 var LLAMA_BUILD = "b9608";
 var REPO = "ggml-org/llama.cpp";
 var CUDA_VER = "13.3";
@@ -327,7 +342,10 @@ function availableBackends(tag = LLAMA_BUILD) {
   const a = arch();
   const def = (id, label, ...assets) => ({ id, label, assets });
   if (plat() === "darwin") {
-    return [def("metal", "Metal (Apple GPU)", `llama-${tag}-bin-macos-${a}.tar.gz`)];
+    return [
+      def("metal", "Metal (Apple GPU)", `llama-${tag}-bin-macos-${a}.tar.gz`),
+      def("cpu", "CPU", `llama-${tag}-bin-macos-${a}.tar.gz`)
+    ];
   }
   if (plat() === "win32") {
     if (a === "arm64") return [def("cpu", "CPU", `llama-${tag}-bin-win-cpu-arm64.zip`)];
@@ -391,9 +409,28 @@ function backendDir(enginesRoot, id, tag = LLAMA_BUILD) {
 function backendDefAt(id, tag) {
   return availableBackends(tag).find((b) => b.id === id) ?? null;
 }
-function installedBackendServer(enginesRoot, id, tag = LLAMA_BUILD) {
-  const dir = backendDir(enginesRoot, id, tag);
-  return existsSync2(dir) ? findServer(dir) : null;
+function installedBackendBuild(enginesRoot, id) {
+  let entries;
+  try {
+    entries = readdirSync(enginesRoot);
+  } catch {
+    return null;
+  }
+  const re = new RegExp(`^llama\\.cpp-(.+)-${id}$`);
+  const buildNum = (tag) => {
+    const m = tag.match(/^b(\d+)$/);
+    return m ? Number(m[1]) : -1;
+  };
+  let best = null;
+  for (const name of entries) {
+    const m = re.exec(name);
+    if (!m) continue;
+    const dir = join2(enginesRoot, name);
+    const bin = findServer(dir);
+    if (!bin) continue;
+    if (!best || buildNum(m[1]) > buildNum(best.tag)) best = { dir, tag: m[1], bin };
+  }
+  return best;
 }
 function findFile(dir, name, skipDir) {
   for (const e of readdirSync(dir, { withFileTypes: true })) {
@@ -437,6 +474,7 @@ async function extractArchive(archive, destDir) {
   } else {
     await execFileP("tar", ["-xzf", archive, "-C", destDir]);
   }
+  stripMacOsQuarantine(destDir);
 }
 async function provisionBackend(enginesRoot, backend, tag, onProgress, signal) {
   const destDir = join2(enginesRoot, `llama.cpp-${tag}-${backend.id}`);
@@ -467,11 +505,21 @@ async function provisionBackend(enginesRoot, backend, tag, onProgress, signal) {
   if (!bin) throw new Error("llama-server not found in extracted archive(s)");
   return bin;
 }
-function deleteBackend(enginesRoot, id, tag = LLAMA_BUILD) {
-  const dir = backendDir(enginesRoot, id, tag);
-  if (!existsSync2(dir)) return false;
-  rmSync(dir, { recursive: true, force: true });
-  return true;
+function deleteAllBackendBuilds(enginesRoot, id) {
+  let entries;
+  try {
+    entries = readdirSync(enginesRoot);
+  } catch {
+    return 0;
+  }
+  const re = new RegExp(`^llama\\.cpp-(.+)-${id}$`);
+  let removed = 0;
+  for (const name of entries) {
+    if (!re.test(name)) continue;
+    rmSync(join2(enginesRoot, name), { recursive: true, force: true });
+    removed++;
+  }
+  return removed;
 }
 function scoreAsset(name, platform = process.platform, archStr = process.arch) {
   const n = name.toLowerCase();
@@ -524,32 +572,6 @@ async function latestCommitSha(repo, branch = "", signal) {
   const data = await res.json();
   return data.sha ?? "";
 }
-async function provisionForkRelease(enginesRoot, repo, destName, onProgress, signal) {
-  const destDir = join2(enginesRoot, destName);
-  if (existsSync2(destDir)) {
-    const found = findServer(destDir);
-    if (found) return found;
-  }
-  const rel = await latestGithubRelease(repo, signal);
-  const asset = pickReleaseAsset(rel.assets ?? []);
-  if (!asset) throw new Error("no_release_asset");
-  mkdirSync2(destDir, { recursive: true });
-  const tmp = join2(enginesRoot, asset.name);
-  try {
-    onProgress?.({ phase: "downloading", pct: 0 });
-    await downloadFile(asset.browser_download_url, tmp, onProgress, signal);
-    onProgress?.({ phase: "extracting", pct: -1 });
-    await extractArchive(tmp, destDir);
-    rmSync(tmp, { force: true });
-  } catch (e) {
-    rmSync(tmp, { force: true });
-    rmSync(destDir, { recursive: true, force: true });
-    throw e;
-  }
-  const bin = findServer(destDir);
-  if (!bin) throw new Error("llama-server not found in extracted release archive");
-  return bin;
-}
 async function turboquantAssetUrl(repo, platform = process.platform, archStr = process.arch, signal) {
   if (platform === "win32") return null;
   const res = await fetch(`https://api.github.com/repos/${repo}/releases?per_page=100`, {
@@ -570,7 +592,10 @@ async function provisionTurboquant(enginesRoot, repo, onProgress, signal) {
   const destDir = join2(enginesRoot, "turboquant");
   if (existsSync2(destDir)) {
     const found = findServer(destDir);
-    if (found) return found;
+    if (found) {
+      stripMacOsQuarantine(destDir);
+      return found;
+    }
   }
   const url = await turboquantAssetUrl(repo, process.platform, process.arch, signal);
   if (!url) throw new Error("no_release_asset");
@@ -1746,7 +1771,8 @@ function isTimeout(err3) {
 function runCaptured(bin, arg) {
   return new Promise((resolve2) => {
     try {
-      execFile5(bin, [arg], { cwd: dirname3(bin), timeout: 1e4, windowsHide: true, maxBuffer: 4 * 1024 * 1024 }, (error, stdout, stderr) => {
+      const timeoutMs = process.platform === "darwin" ? 6e4 : 15e3;
+      execFile5(bin, [arg], { cwd: dirname3(bin), timeout: timeoutMs, windowsHide: true, maxBuffer: 4 * 1024 * 1024 }, (error, stdout, stderr) => {
         resolve2({ out: (stdout || "") + (stderr || ""), err: error });
       });
     } catch (e) {
@@ -1770,7 +1796,8 @@ async function probe(bin) {
   const h = await runCaptured(bin, "--help");
   if (v.err && h.err) {
     if (isTimeout(v.err) && isTimeout(h.err)) {
-      throw new ProbeError("probe_timeout", "The binary did not respond within 10 seconds.");
+      const timeoutSec = process.platform === "darwin" ? 60 : 15;
+      throw new ProbeError("probe_timeout", `The binary did not respond within ${timeoutSec} seconds.`);
     }
     let msg2 = "Could not run the binary (--version and --help both failed).";
     const tail = lastLine(v.out);
@@ -2110,6 +2137,40 @@ var ProvisionState = class {
   }
 };
 
+// src/engines/build-state.ts
+var LOG_TAIL = 200;
+var BuildState = class {
+  s = { active: false, phase: "preparing", engine: "", log: [], error: null };
+  get() {
+    return { ...this.s, log: [...this.s.log] };
+  }
+  /** True while a build is running — used to reject a concurrent build/download. */
+  isActive() {
+    return this.s.active;
+  }
+  start(engine) {
+    this.s = { active: true, phase: "preparing", engine, log: [], error: null };
+  }
+  phase(phase) {
+    if (!this.s.active) return;
+    this.s.phase = phase;
+  }
+  /** Append a log line (split multi-line chunks upstream). Keeps only the last N. */
+  log(line) {
+    if (!this.s.active) return;
+    const trimmed = line.replace(/\r?\n$/, "");
+    if (trimmed === "") return;
+    this.s.log.push(trimmed);
+    if (this.s.log.length > LOG_TAIL) this.s.log.splice(0, this.s.log.length - LOG_TAIL);
+  }
+  done() {
+    this.s = { ...this.s, active: false, phase: "done", error: null };
+  }
+  fail(error) {
+    this.s = { ...this.s, active: false, phase: "error", error };
+  }
+};
+
 // src/engines/update.ts
 function parseBuildTag(tag) {
   const m = /^v?b(\d+)$/i.exec(tag.trim());
@@ -2433,7 +2494,7 @@ import { rmSync as rmSync5 } from "fs";
 import { join as join9 } from "path";
 
 // src/sysinfo/sysinfo.ts
-import { execFileSync } from "child_process";
+import { execFileSync as execFileSync2 } from "child_process";
 import os from "os";
 import fs from "fs";
 var cached = null;
@@ -2464,7 +2525,7 @@ function classifyVendor(name) {
 }
 function detectGpus() {
   try {
-    const out = execFileSync("nvidia-smi", ["--query-gpu=name,memory.total", "--format=csv,noheader,nounits"], {
+    const out = execFileSync2("nvidia-smi", ["--query-gpu=name,memory.total", "--format=csv,noheader,nounits"], {
       timeout: 8e3,
       windowsHide: true
     }).toString();
@@ -2477,7 +2538,7 @@ function detectGpus() {
   }
   if (process.platform === "darwin") {
     try {
-      const out = execFileSync("system_profiler", ["SPDisplaysDataType"], { timeout: 8e3 }).toString();
+      const out = execFileSync2("system_profiler", ["SPDisplaysDataType"], { timeout: 8e3 }).toString();
       const m = out.match(/Chipset Model:\s*(.+)/);
       if (m && /Apple/.test(out)) {
         return [{ name: m[1].trim(), vramMb: Math.round(os.totalmem() / 1e6 * 0.65), vendor: "apple" }];
@@ -2494,7 +2555,7 @@ function detectGpus() {
 }
 function enumWindowsGpus() {
   const ps = 'Get-CimInstance Win32_VideoController | ForEach-Object { "$($_.Name)|$($_.AdapterRAM)" }';
-  const out = execFileSync("powershell", ["-NoProfile", "-NonInteractive", "-Command", ps], {
+  const out = execFileSync2("powershell", ["-NoProfile", "-NonInteractive", "-Command", ps], {
     timeout: 8e3,
     windowsHide: true
   }).toString();
@@ -2506,7 +2567,7 @@ function enumWindowsGpus() {
   }).filter((g) => g.name && g.vendor !== "unknown");
 }
 function enumLinuxGpus() {
-  const out = execFileSync("sh", ["-c", "lspci -mm 2>/dev/null | grep -iE 'VGA|3D|Display'"], {
+  const out = execFileSync2("sh", ["-c", "lspci -mm 2>/dev/null | grep -iE 'VGA|3D|Display'"], {
     timeout: 8e3
   }).toString();
   return out.trim().split("\n").filter(Boolean).map((line) => {
@@ -2589,10 +2650,9 @@ async function applyForkUpdate(d, engine, root, signal) {
     if (oldEng && d.registry.active()?.id === oldEng.id) await d.manager.stopAndWait();
     const tqDir = join9(root, "turboquant");
     rmSync5(tqDir, { recursive: true, force: true });
-    const bin = await provisionForkRelease(
+    const bin = await provisionTurboquant(
       root,
       "AtomicBot-ai/atomic-llama-cpp-turboquant",
-      "turboquant",
       (p) => d.provision.progress(p.phase, p.pct, p.part, p.parts),
       signal
     );
@@ -6353,15 +6413,15 @@ Install it:  ${spec.install}
 // src/server.ts
 import { Hono } from "hono";
 import { cors } from "hono/cors";
-import { existsSync as existsSync16, readFileSync as readFileSync8, statSync as statSync6 } from "fs";
+import { existsSync as existsSync18, readFileSync as readFileSync9, statSync as statSync6 } from "fs";
 import { fileURLToPath } from "url";
-import { dirname as dirname7, join as join18, normalize as normalize2 } from "path";
+import { dirname as dirname8, join as join20, normalize as normalize2 } from "path";
 import { Agent, setGlobalDispatcher } from "undici";
 
 // src/api/routes.ts
 import { streamSSE as streamSSE2 } from "hono/streaming";
-import { existsSync as existsSync15, mkdirSync as mkdirSync10, readFileSync as readFileSync7, readdirSync as readdirSync5, realpathSync, rmSync as rmSync8, statSync as statSync5, writeFileSync as writeFileSync7 } from "fs";
-import { basename as basename3, dirname as dirname6, join as join17, resolve, sep } from "path";
+import { existsSync as existsSync17, mkdirSync as mkdirSync12, readFileSync as readFileSync8, readdirSync as readdirSync7, realpathSync, rmSync as rmSync10, statSync as statSync5, writeFileSync as writeFileSync8 } from "fs";
+import { basename as basename3, dirname as dirname7, join as join19, resolve, sep } from "path";
 
 // src/comfyui/gate-template.ts
 var GATE_VERSION = 2;
@@ -7900,9 +7960,17 @@ function catalogEngine(id) {
 
 // src/engines/build-prereqs.ts
 import { execFile as execFile7 } from "child_process";
-import { join as join16 } from "path";
+import { delimiter, join as join16 } from "path";
 import { promisify as promisify4 } from "util";
 var execFileP4 = promisify4(execFile7);
+function buildEnv(toolchainDirs = []) {
+  const dirs = toolchainDirs.map((d) => d.trim()).filter(Boolean);
+  if (dirs.length === 0) return { ...process.env };
+  const env = { ...process.env };
+  const key = Object.keys(env).find((k) => k.toLowerCase() === "path") ?? "PATH";
+  env[key] = [...dirs, env[key] ?? ""].filter(Boolean).join(delimiter);
+  return env;
+}
 var INSTALL_URLS = {
   git: "https://git-scm.com/downloads",
   cmake: "https://cmake.org/download/",
@@ -7910,11 +7978,12 @@ var INSTALL_URLS = {
   // The "Desktop development with C++" workload from the VS Build Tools installer.
   msvc: "https://visualstudio.microsoft.com/downloads/"
 };
-async function runVersion(cmd, args) {
+async function runVersion(cmd, args, env) {
   const { stdout, stderr } = await execFileP4(cmd, args, {
     timeout: 8e3,
     windowsHide: true,
-    maxBuffer: 1024 * 1024
+    maxBuffer: 1024 * 1024,
+    env
   });
   return (stdout || stderr || "").trim();
 }
@@ -7930,40 +7999,40 @@ function parseNvccVersion(out) {
   const m = out.match(/release\s+([\d.]+)/i);
   return m ? m[1] : "";
 }
-async function checkGit() {
+async function checkGit(env) {
   let found = false;
   let version2;
   try {
-    version2 = parseGitVersion(await runVersion("git", ["--version"])) || void 0;
+    version2 = parseGitVersion(await runVersion("git", ["--version"], env)) || void 0;
     found = true;
   } catch {
     found = false;
   }
   return { id: "git", name: "Git", found, version: version2, installUrl: INSTALL_URLS.git };
 }
-async function checkCmake() {
+async function checkCmake(env) {
   let found = false;
   let version2;
   try {
-    version2 = parseCmakeVersion(await runVersion("cmake", ["--version"])) || void 0;
+    version2 = parseCmakeVersion(await runVersion("cmake", ["--version"], env)) || void 0;
     found = true;
   } catch {
     found = false;
   }
   return { id: "cmake", name: "CMake", found, version: version2, installUrl: INSTALL_URLS.cmake };
 }
-async function checkCuda() {
+async function checkCuda(env) {
   let found = false;
   let version2;
   try {
-    version2 = parseNvccVersion(await runVersion("nvcc", ["--version"])) || void 0;
+    version2 = parseNvccVersion(await runVersion("nvcc", ["--version"], env)) || void 0;
     found = true;
   } catch {
     found = false;
   }
   return { id: "cuda", name: "CUDA Toolkit", found, version: version2, installUrl: INSTALL_URLS.cuda };
 }
-async function checkMsvc() {
+async function checkMsvc(env) {
   let found = false;
   let version2;
   try {
@@ -7977,7 +8046,7 @@ async function checkMsvc() {
       "Microsoft.VisualStudio.Component.VC.Tools.x86.x64",
       "-property",
       "installationVersion"
-    ]);
+    ], env);
     version2 = out.split(/\r?\n/)[0]?.trim() || void 0;
     found = !!version2;
   } catch {
@@ -7991,14 +8060,398 @@ async function checkMsvc() {
     installUrl: INSTALL_URLS.msvc
   };
 }
-async function checkBuildPrereqs() {
+async function checkBuildPrereqs(toolchainDirs = []) {
   if (process.platform !== "win32") {
     return { supported: false, tools: [] };
   }
-  const tools = await Promise.all([checkGit(), checkCmake(), checkCuda(), checkMsvc()]);
+  const env = buildEnv(toolchainDirs);
+  const tools = await Promise.all([checkGit(env), checkCmake(env), checkCuda(env), checkMsvc(env)]);
   return { supported: true, tools };
 }
 
+// src/engines/build-runner.ts
+import { execFile as execFile8, spawn as spawn4 } from "child_process";
+import { copyFileSync, existsSync as existsSync15, mkdirSync as mkdirSync10, readFileSync as readFileSync7, readdirSync as readdirSync5, rmSync as rmSync8, writeFileSync as writeFileSync7 } from "fs";
+import { delimiter as delimiter2, dirname as dirname6, join as join17 } from "path";
+import { promisify as promisify5 } from "util";
+var execFileP5 = promisify5(execFile8);
+function buildDirName(repoUrl, branch) {
+  const last = repoUrl.trim().replace(/\/+$/, "").split(/[\\/]/).pop() ?? "";
+  const repo = last.replace(/\.git$/i, "").trim() || "engine";
+  const b = (branch ?? "").trim();
+  const raw = b ? `${repo}-${b}` : repo;
+  return raw.replace(/[^A-Za-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "") || "engine";
+}
+function sameRepo(a, b) {
+  const norm = (s) => (s ?? "").trim().toLowerCase().replace(/^https?:\/\//, "").replace(/^github\.com\//, "").replace(/\.git$/, "").replace(/\/+$/, "");
+  const na = norm(a);
+  return na !== "" && na === norm(b);
+}
+function sourceBuildBinary(enginesRoot, repoUrl, branch) {
+  const root = join17(enginesRoot, "build", buildDirName(repoUrl, branch));
+  return resolveServerBinary(join17(root, "build")) ?? resolveServerBinary(root);
+}
+function sourceBuildDirOf(binPath, enginesRoot) {
+  const m = binPath.replace(/\\/g, "/").match(/\/engines\/build\/([^/]+)(?:\/|$)/i);
+  if (!m) return null;
+  return join17(enginesRoot, "build", m[1]);
+}
+function pickGenerator(hasNinja) {
+  return hasNinja ? "Ninja" : "NMake Makefiles";
+}
+var CMAKE_CONFIGURE_ARGS = ["-DGGML_CUDA=ON", "-DCMAKE_BUILD_TYPE=Release"];
+function vcvarsBatch(vcvars, cmakeArgs) {
+  const quoted = cmakeArgs.map((a) => /[\s"]/.test(a) ? `"${a}"` : a).join(" ");
+  return [
+    "@echo off",
+    `call "${vcvars}" x64`,
+    "if errorlevel 1 exit /b 1",
+    `cmake ${quoted}`,
+    "exit /b %errorlevel%",
+    ""
+  ].join("\r\n");
+}
+function onPath(env, exe) {
+  const key = Object.keys(env).find((k) => k.toLowerCase() === "path") ?? "PATH";
+  return (env[key] ?? "").split(delimiter2).filter(Boolean).some((dir) => {
+    try {
+      return existsSync15(join17(dir, exe));
+    } catch {
+      return false;
+    }
+  });
+}
+var CUDA_RUNTIME_DLL_PREFIXES = ["cudart64_", "cublas64_", "cublaslt64_", "nvrtc64_", "nvrtc-builtins64_", "nvjitlink_"];
+function cudaDllSourceDirs(env) {
+  const key = Object.keys(env).find((k) => k.toLowerCase() === "path") ?? "PATH";
+  const pathDirs = (env[key] ?? "").split(delimiter2).filter(Boolean);
+  const nvccDir = pathDirs.find((dir) => {
+    try {
+      return existsSync15(join17(dir, "nvcc.exe"));
+    } catch {
+      return false;
+    }
+  });
+  if (!nvccDir) return [];
+  return [nvccDir, join17(nvccDir, "x64")].filter((d) => {
+    try {
+      return existsSync15(d);
+    } catch {
+      return false;
+    }
+  });
+}
+function copyCudaRuntimeDlls(env, destDir, log) {
+  const sources = cudaDllSourceDirs(env);
+  if (sources.length === 0) {
+    log("Note: could not find the CUDA toolkit DLLs to bundle \u2014 the engine may need the CUDA bin on PATH to run.");
+    return 0;
+  }
+  const seen = /* @__PURE__ */ new Set();
+  let copied = 0;
+  for (const dir of sources) {
+    let names;
+    try {
+      names = readdirSync5(dir);
+    } catch {
+      continue;
+    }
+    for (const name of names) {
+      const lower = name.toLowerCase();
+      if (!lower.endsWith(".dll")) continue;
+      if (seen.has(lower)) continue;
+      if (!CUDA_RUNTIME_DLL_PREFIXES.some((p) => lower.startsWith(p))) continue;
+      try {
+        copyFileSync(join17(dir, name), join17(destDir, name));
+        seen.add(lower);
+        copied++;
+      } catch {
+      }
+    }
+  }
+  if (copied > 0) log(`Bundled ${copied} CUDA runtime DLL(s) next to the binary so the engine is self-contained.`);
+  return copied;
+}
+async function findVcvarsall() {
+  try {
+    const programFilesX86 = process.env["ProgramFiles(x86)"] || "C:\\Program Files (x86)";
+    const vswhere = join17(programFilesX86, "Microsoft Visual Studio", "Installer", "vswhere.exe");
+    const { stdout } = await execFileP5(
+      vswhere,
+      ["-latest", "-products", "*", "-requires", "Microsoft.VisualStudio.Component.VC.Tools.x86.x64", "-find", "VC\\Auxiliary\\Build\\vcvarsall.bat"],
+      { timeout: 8e3, windowsHide: true, maxBuffer: 1024 * 1024 }
+    );
+    const p = stdout.split(/\r?\n/).map((s) => s.trim()).find(Boolean);
+    return p && existsSync15(p) ? p : null;
+  } catch {
+    return null;
+  }
+}
+function runStep(cmd, args, opts) {
+  return new Promise((resolve2, reject) => {
+    const child = spawn4(cmd, args, {
+      cwd: opts.cwd,
+      env: opts.env,
+      signal: opts.signal,
+      windowsHide: true,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    let stdout = "";
+    let outBuf = "";
+    let errBuf = "";
+    const pump = (chunk, isErr) => {
+      if (!isErr) stdout += chunk;
+      let buf = isErr ? errBuf + chunk : outBuf + chunk;
+      let nl;
+      while ((nl = buf.indexOf("\n")) >= 0) {
+        opts.onLine(buf.slice(0, nl).replace(/\r$/, ""));
+        buf = buf.slice(nl + 1);
+      }
+      if (isErr) errBuf = buf;
+      else outBuf = buf;
+    };
+    child.stdout.setEncoding("utf8");
+    child.stderr.setEncoding("utf8");
+    child.stdout.on("data", (c) => pump(c, false));
+    child.stderr.on("data", (c) => pump(c, true));
+    child.on("error", (e) => reject(e));
+    child.on("close", (code) => {
+      if (outBuf) opts.onLine(outBuf.replace(/\r$/, ""));
+      if (errBuf) opts.onLine(errBuf.replace(/\r$/, ""));
+      if (code === 0) resolve2(stdout);
+      else reject(new Error(`${cmd} exited with code ${code}`));
+    });
+  });
+}
+function hasAssemblySources(dir) {
+  const SKIP = /* @__PURE__ */ new Set([".git", "build", "node_modules", ".cache", "vendor"]);
+  const stack = [dir];
+  while (stack.length) {
+    const d = stack.pop();
+    let entries;
+    try {
+      entries = readdirSync5(d, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const e of entries) {
+      if (e.isDirectory()) {
+        if (!SKIP.has(e.name.toLowerCase()) && !e.name.startsWith(".")) stack.push(join17(d, e.name));
+      } else if (/\.(s|asm)$/i.test(e.name)) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+function stripGenericAsmLanguage(text) {
+  let changed = false;
+  const out = text.split(/\r?\n/).map((line) => {
+    if (/\bproject\s*\(/i.test(line) && /\bASM\b/.test(line)) {
+      const next = line.replace(/\s+ASM\b/g, "");
+      if (next !== line) {
+        changed = true;
+        return next;
+      }
+    }
+    if (/^\s*enable_language\s*\(\s*ASM\s*\)/i.test(line)) {
+      changed = true;
+      return `# ${line}  # neutralized by TurboLLM (no assembly sources)`;
+    }
+    return line;
+  });
+  return { text: out.join("\n"), changed };
+}
+function neutralizeGratuitousAsm(srcDir, log) {
+  if (hasAssemblySources(srcDir)) return;
+  const candidates = [join17(srcDir, "CMakeLists.txt"), join17(srcDir, "ggml", "CMakeLists.txt")];
+  let patched = 0;
+  for (const file of candidates) {
+    if (!existsSync15(file)) continue;
+    let text;
+    try {
+      text = readFileSync7(file, "utf8");
+    } catch {
+      continue;
+    }
+    const { text: next, changed } = stripGenericAsmLanguage(text);
+    if (changed) {
+      try {
+        writeFileSync7(file, next);
+        patched++;
+      } catch {
+      }
+    }
+  }
+  if (patched > 0) {
+    log(
+      "Removed an unused CMake ASM-language declaration (the repo ships no assembly sources) so the build works with MSVC \u2014 this fork enables ASM gratuitously, which modern CMake rejects with MSVC."
+    );
+  }
+}
+async function runBuild(req, hooks, signal) {
+  const env = { ...buildEnv(req.toolchainDirs), GIT_TERMINAL_PROMPT: "0", GCM_INTERACTIVE: "never" };
+  hooks.phase("preparing");
+  const prereqs = await checkBuildPrereqs(req.toolchainDirs);
+  if (!prereqs.supported) throw new Error("In-app build is currently Windows + CUDA only.");
+  const missing = prereqs.tools.filter((t) => (t.id === "git" || t.id === "cmake" || t.id === "cuda") && !t.found);
+  if (missing.length > 0) {
+    const names = missing.map((t) => t.name).join(", ");
+    throw new Error(
+      `Missing build prerequisite(s): ${names}. Install them, or \u2014 if they live in a conda env / custom path \u2014 add that folder under Build environment so TurboLLM can find them.`
+    );
+  }
+  const vcvars = await findVcvarsall();
+  if (!vcvars) {
+    throw new Error(
+      'Could not locate the Visual Studio C++ build environment (vcvarsall.bat). Install the "Desktop development with C++" workload from the Visual Studio Build Tools.'
+    );
+  }
+  const buildRoot = join17(req.enginesRoot, "build", buildDirName(req.repoUrl, req.branch));
+  const srcDir = join17(buildRoot, "src");
+  const buildSubdir = join17(buildRoot, "build");
+  rmSync8(buildRoot, { recursive: true, force: true });
+  mkdirSync10(buildRoot, { recursive: true });
+  hooks.phase("cloning");
+  const cloneArgs = ["clone", "--depth", "1"];
+  if ((req.branch ?? "").trim()) cloneArgs.push("--branch", req.branch.trim());
+  cloneArgs.push(req.repoUrl, srcDir);
+  await runStep("git", cloneArgs, { env, signal, onLine: hooks.log });
+  const commit = (await runStep("git", ["-C", srcDir, "rev-parse", "HEAD"], { env, signal, onLine: () => {
+  } })).trim();
+  neutralizeGratuitousAsm(srcDir, hooks.log);
+  const generator = pickGenerator(onPath(env, "ninja.exe"));
+  hooks.log(
+    generator === "Ninja" ? "Using the Ninja generator (drives nvcc directly \u2014 no Visual Studio CUDA integration needed)." : "Ninja not found on PATH \u2014 using the NMake generator (works, but single-threaded and slower; add a folder containing ninja.exe under Build environment for much faster builds)."
+  );
+  hooks.phase("configuring");
+  const configureBat = join17(buildRoot, "_tllm_configure.bat");
+  writeFileSync7(configureBat, vcvarsBatch(vcvars, ["-G", generator, "-B", buildSubdir, "-S", srcDir, ...CMAKE_CONFIGURE_ARGS]));
+  await runStep("cmd.exe", ["/c", configureBat], { cwd: buildRoot, env, signal, onLine: hooks.log });
+  hooks.phase("compiling");
+  const compileBat = join17(buildRoot, "_tllm_build.bat");
+  writeFileSync7(compileBat, vcvarsBatch(vcvars, ["--build", buildSubdir, "-j", "--target", "llama-server"]));
+  await runStep("cmd.exe", ["/c", compileBat], { cwd: buildRoot, env, signal, onLine: hooks.log });
+  hooks.phase("registering");
+  const binPath = resolveServerBinary(buildSubdir) ?? resolveServerBinary(buildRoot);
+  if (!binPath) {
+    throw new Error("Build finished but no llama-server binary was found in the output \u2014 see the log above.");
+  }
+  copyCudaRuntimeDlls(env, dirname6(binPath), hooks.log);
+  return { binPath, commit, buildRoot };
+}
+
+// src/engines/cuda-provision.ts
+import { execFile as execFile9 } from "child_process";
+import { cpSync as cpSync2, existsSync as existsSync16, mkdirSync as mkdirSync11, readdirSync as readdirSync6, rmSync as rmSync9 } from "fs";
+import { tmpdir } from "os";
+import { join as join18 } from "path";
+import { promisify as promisify6 } from "util";
+var execFileP6 = promisify6(execFile9);
+var REDIST_BASE = "https://developer.download.nvidia.com/compute/cuda/redist/";
+var CUDA_REQUIRED_COMPONENTS = ["cuda_nvcc", "cuda_cudart", "libcublas", "cuda_cccl"];
+var CUDA_OPTIONAL_COMPONENTS = ["libnvvm", "cuda_crt"];
+var KNOWN_CUDA_VERSIONS = ["13.0.1", "13.0.0", "12.8.1", "12.6.3", "12.4.1"];
+function majorMinor(v) {
+  const p = v.split(".");
+  return `${p[0] ?? "0"}.${p[1] ?? "0"}`;
+}
+function cmpMajorMinor(a, b) {
+  const [am, an] = a.split(".").map(Number);
+  const [bm, bn] = b.split(".").map(Number);
+  return am !== bm ? am - bm : (an || 0) - (bn || 0);
+}
+async function driverMaxCuda() {
+  try {
+    const { stdout } = await execFileP6("nvidia-smi", [], { timeout: 8e3, windowsHide: true, maxBuffer: 1024 * 1024 });
+    const m = stdout.match(/CUDA Version:\s*([\d.]+)/i);
+    return m ? m[1] : null;
+  } catch {
+    return null;
+  }
+}
+function pickCudaVersion(driverMax, known = KNOWN_CUDA_VERSIONS) {
+  if (!driverMax) return known[0];
+  const dm = majorMinor(driverMax);
+  return known.find((v) => cmpMajorMinor(majorMinor(v), dm) <= 0) ?? known[known.length - 1];
+}
+async function fetchManifest(version2, signal) {
+  const res = await fetch(`${REDIST_BASE}redistrib_${version2}.json`, { redirect: "follow", signal });
+  if (!res.ok) return null;
+  return await res.json();
+}
+async function resolveVersion(driverMax, signal) {
+  const preferred = pickCudaVersion(driverMax);
+  const ordered = [preferred, ...KNOWN_CUDA_VERSIONS.filter((v) => v !== preferred)];
+  for (const version2 of ordered) {
+    const manifest = await fetchManifest(version2, signal);
+    if (manifest) return { version: version2, manifest };
+  }
+  throw new Error("Could not reach NVIDIA to resolve a CUDA Toolkit version (offline?).");
+}
+async function provisionCuda(dataDir, onProgress, signal) {
+  if (process.platform !== "win32") {
+    throw new Error("Automatic CUDA download is currently Windows x86_64 only.");
+  }
+  onProgress({ phase: "resolving", message: "Checking your NVIDIA driver and resolving a CUDA version\u2026" });
+  const driverMax = await driverMaxCuda();
+  const { version: version2, manifest } = await resolveVersion(driverMax, signal);
+  onProgress({
+    phase: "resolving",
+    message: `Using CUDA ${version2}${driverMax ? ` (driver supports up to ${driverMax})` : ""}.`
+  });
+  const root = join18(dataDir, "cuda", version2);
+  const binDir = join18(root, "bin");
+  if (existsSync16(join18(binDir, "nvcc.exe"))) {
+    onProgress({ phase: "assembling", message: `CUDA ${version2} already downloaded \u2014 reusing it.` });
+    return { root, binDir, version: version2 };
+  }
+  const relOf = (id) => manifest[id]?.["windows-x86_64"]?.relative_path;
+  const components = [];
+  for (const id of CUDA_REQUIRED_COMPONENTS) {
+    const rel = relOf(id);
+    if (!rel) throw new Error(`CUDA ${version2} manifest is missing ${id} for windows-x86_64.`);
+    components.push({ id, url: REDIST_BASE + rel });
+  }
+  for (const id of CUDA_OPTIONAL_COMPONENTS) {
+    const rel = relOf(id);
+    if (rel) components.push({ id, url: REDIST_BASE + rel });
+  }
+  const work = join18(tmpdir(), `tllm-cuda-${version2}`);
+  rmSync9(work, { recursive: true, force: true });
+  mkdirSync11(work, { recursive: true });
+  const stageRoot = `${root}.partial`;
+  rmSync9(stageRoot, { recursive: true, force: true });
+  mkdirSync11(stageRoot, { recursive: true });
+  try {
+    for (let i = 0; i < components.length; i++) {
+      const { id, url } = components[i];
+      const zip = join18(work, `${id}.zip`);
+      onProgress({ phase: "downloading", message: `Downloading ${id} (${i + 1}/${components.length})\u2026`, pct: 0 });
+      await downloadFile(url, zip, (p) => onProgress({ phase: "downloading", message: `Downloading ${id} (${i + 1}/${components.length})\u2026`, pct: p.pct }), signal);
+      const exDir = join18(work, id);
+      mkdirSync11(exDir, { recursive: true });
+      onProgress({ phase: "extracting", message: `Extracting ${id}\u2026` });
+      await extractArchive(zip, exDir);
+      const inner = readdirSync6(exDir).map((n) => join18(exDir, n)).find((p) => existsSync16(join18(p, "include")) || existsSync16(join18(p, "bin")) || existsSync16(join18(p, "lib")));
+      const srcRoot = inner ?? join18(exDir, readdirSync6(exDir)[0] ?? "");
+      cpSync2(srcRoot, stageRoot, { recursive: true, force: true });
+      rmSync9(zip, { force: true });
+    }
+    if (!existsSync16(join18(stageRoot, "bin", "nvcc.exe"))) {
+      throw new Error("Assembled CUDA toolkit is missing bin/nvcc.exe \u2014 the component set may have changed.");
+    }
+    rmSync9(root, { recursive: true, force: true });
+    mkdirSync11(join18(dataDir, "cuda"), { recursive: true });
+    cpSync2(stageRoot, root, { recursive: true, force: true });
+    onProgress({ phase: "assembling", message: `CUDA ${version2} ready.` });
+    return { root, binDir, version: version2 };
+  } finally {
+    rmSync9(work, { recursive: true, force: true });
+    rmSync9(stageRoot, { recursive: true, force: true });
+  }
+}
+
 // src/engines/hardware.ts
 function detectHardware(info = getSysInfo()) {
   const arch2 = process.arch === "arm64" ? "arm64" : "x64";
@@ -8106,6 +8559,8 @@ function registerApi(app2, d) {
       bench: d.bench.status(),
       downloads: { active: d.downloads.activeCount() },
       engineProvision: d.provision.get(),
+      // In-app compile-from-source status (ADR-100): live phase + log tail while a build runs.
+      engineBuild: d.build.get(),
       // ComfyUI GPU coordination: lets the UI explain a paused/unloaded engine.
       // Also expose the installed gate node version so the UI can prompt an upgrade.
       comfyui: (() => {
@@ -8115,7 +8570,7 @@ function registerApi(app2, d) {
         let installedVersion = null;
         if (gatePath) {
           try {
-            const src = readFileSync7(join17(gatePath, "__init__.py"), "utf-8");
+            const src = readFileSync8(join19(gatePath, "__init__.py"), "utf-8");
             const m = src.match(/^GATE_VERSION\s*=\s*(\d+)/m);
             if (m) installedVersion = Number(m[1]);
           } catch {
@@ -8132,28 +8587,34 @@ function registerApi(app2, d) {
     return c.json({ engines, activeEngineId });
   });
   let provisionAbort = null;
+  let buildAbort = null;
   app2.get("/api/v1/engines/backends", (c) => {
     const sys = getSysInfo();
     const vendor = primaryVendor(sys);
     const recommended = recommendBackendId(vendor, sys.gpus.length > 0);
-    const root = join17(d.store.dir(), "engines");
+    const root = join19(d.store.dir(), "engines");
     const active = d.registry.active();
     const regEngines = d.registry.list().engines;
+    const backendOf = (p) => p.match(/llama\.cpp-[^/\\]+-(cuda|rocm|sycl|vulkan|metal|cpu)/i)?.[1]?.toLowerCase();
+    const buildNumOf = (p) => {
+      const m = p.match(/llama\.cpp-b(\d+)/i);
+      return m ? Number(m[1]) : -1;
+    };
     const backends = availableBackends().map((b) => {
-      const bin = installedBackendServer(root, b.id);
-      const eng = bin ? regEngines.find((e) => e.binPath === bin) : void 0;
+      const builds = regEngines.filter((e) => backendOf(e.binPath) === b.id).sort((x, y) => buildNumOf(y.binPath) - buildNumOf(x.binPath));
+      const eng = builds[0];
       return {
         id: b.id,
         label: b.label,
-        installed: !!bin,
+        installed: !!eng,
         enabled: !!eng,
         recommended: b.id === recommended,
-        active: !!bin && !!active && active.binPath === bin,
+        active: !!eng && !!active && active.id === eng.id,
         engineId: eng?.id ?? ""
       };
     });
-    const mlxVenvPy = join17(root, "mlx", "venv", process.platform === "win32" ? "Scripts/python.exe" : "bin/python");
-    const mlxInstalledOnDisk = existsSync15(mlxVenvPy);
+    const mlxVenvPy = join19(root, "mlx", "venv", process.platform === "win32" ? "Scripts/python.exe" : "bin/python");
+    const mlxInstalledOnDisk = existsSync17(mlxVenvPy);
     const mlxEngine = regEngines.find((e) => e.kind === "mlx");
     const mlx = {
       supported: process.platform === "darwin",
@@ -8168,11 +8629,15 @@ function registerApi(app2, d) {
     const b = await body2(c);
     const def = availableBackends().find((x) => x.id === b.backend);
     if (!def) return err2(c, 400, "invalid_config_value", "Unknown backend for this platform.");
-    const root = join17(d.store.dir(), "engines");
-    if (installedBackendServer(root, def.id)) {
-      return c.json({ accepted: false, alreadyInstalled: true, build: LLAMA_BUILD });
+    const root = join19(d.store.dir(), "engines");
+    const existing = installedBackendBuild(root, def.id);
+    if (existing) {
+      return c.json({ accepted: false, alreadyInstalled: true, build: existing.tag });
+    }
+    {
+      const busy = engineWorkBusy(d);
+      if (busy) return err2(c, 409, "engine_already_running", busy);
     }
-    if (d.provision.get().active) return err2(c, 409, "engine_already_running", "Another engine download is already in progress.");
     const ac = new AbortController();
     provisionAbort = ac;
     void (async () => {
@@ -8208,10 +8673,13 @@ function registerApi(app2, d) {
   app2.post("/api/v1/engines/backends/:id/update", async (c) => {
     const def = availableBackends().find((x) => x.id === c.req.param("id"));
     if (!def) return err2(c, 400, "invalid_config_value", "Unknown backend for this platform.");
-    const root = join17(d.store.dir(), "engines");
-    const oldBin = installedBackendServer(root, def.id);
+    const root = join19(d.store.dir(), "engines");
+    const oldBin = installedBackendBuild(root, def.id)?.bin ?? null;
     if (!oldBin) return err2(c, 409, "not_installed", "Backend is not installed \u2014 download it first.");
-    if (d.provision.get().active) return err2(c, 409, "engine_already_running", "Another engine download is already in progress.");
+    {
+      const busy = engineWorkBusy(d);
+      if (busy) return err2(c, 409, "engine_already_running", busy);
+    }
     let latestTag;
     try {
       latestTag = await latestReleaseTag("ggml-org/llama.cpp", AbortSignal.timeout(15e3));
@@ -8249,7 +8717,7 @@ function registerApi(app2, d) {
           }
         }
         if (installedTag && installedTag !== latestTag) {
-          rmSync8(backendDir(root, def.id, installedTag), { recursive: true, force: true });
+          rmSync10(backendDir(root, def.id, installedTag), { recursive: true, force: true });
         }
         d.provision.done();
       } catch (e) {
@@ -8264,31 +8732,40 @@ function registerApi(app2, d) {
   app2.post("/api/v1/engines/backends/:id/enable", async (c) => {
     const def = availableBackends().find((x) => x.id === c.req.param("id"));
     if (!def) return err2(c, 400, "invalid_config_value", "Unknown backend for this platform.");
-    const root = join17(d.store.dir(), "engines");
-    const bin = installedBackendServer(root, def.id);
-    if (!bin) return err2(c, 409, "not_installed", "Backend is not installed on disk \u2014 download it first.");
-    let eng = d.registry.list().engines.find((e) => e.binPath === bin);
-    if (!eng) eng = (await d.registry.add(`llama.cpp ${LLAMA_BUILD} (${def.id})`, bin)).engine;
+    const root = join19(d.store.dir(), "engines");
+    const build2 = installedBackendBuild(root, def.id);
+    if (!build2) return err2(c, 409, "not_installed", "Backend is not installed on disk \u2014 download it first.");
+    let eng = d.registry.list().engines.find((e) => e.binPath === build2.bin);
+    if (!eng) eng = (await d.registry.add(`llama.cpp ${build2.tag} (${def.id})`, build2.bin)).engine;
     d.registry.activate(eng.id);
     return c.json({ ok: true, engineId: eng.id });
   });
   app2.delete("/api/v1/engines/backends/:id", async (c) => {
     const def = availableBackends().find((x) => x.id === c.req.param("id"));
     if (!def) return err2(c, 400, "invalid_config_value", "Unknown backend for this platform.");
-    const root = join17(d.store.dir(), "engines");
-    const bin = installedBackendServer(root, def.id);
-    const eng = bin ? d.registry.list().engines.find((e) => e.binPath === bin) : void 0;
-    if (eng && d.registry.active()?.id === eng.id) await d.manager.stopAndWait();
-    if (eng) d.registry.remove(eng.id);
-    deleteBackend(root, def.id, LLAMA_BUILD);
+    const root = join19(d.store.dir(), "engines");
+    const backendDirRe = new RegExp(`[\\\\/]engines[\\\\/]llama\\.cpp-[^\\\\/]+-${def.id}[\\\\/]`);
+    const engs = d.registry.list().engines.filter((e) => backendDirRe.test(e.binPath));
+    const activeId = d.registry.active()?.id;
+    if (engs.some((e) => e.id === activeId)) await d.manager.stopAndWait();
+    for (const e of engs) {
+      try {
+        d.registry.remove(e.id);
+      } catch {
+      }
+    }
+    deleteAllBackendBuilds(root, def.id);
     return c.json({ ok: true });
   });
   app2.post("/api/v1/engines/mlx", (c) => {
     if (process.platform !== "darwin") {
       return err2(c, 409, "unsupported_platform", "MLX is only available on macOS (Apple Silicon).");
     }
-    if (d.provision.get().active) return err2(c, 409, "engine_already_running", "Another engine download is already in progress.");
-    const root = join17(d.store.dir(), "engines");
+    {
+      const busy = engineWorkBusy(d);
+      if (busy) return err2(c, 409, "engine_already_running", busy);
+    }
+    const root = join19(d.store.dir(), "engines");
     const upgrade = c.req.query("update") === "1";
     void (async () => {
       try {
@@ -8305,32 +8782,51 @@ function registerApi(app2, d) {
   });
   app2.get("/api/v1/engines/catalog", (c) => {
     const regEngines = d.registry.list().engines;
-    const enginesRoot = join17(d.store.dir(), "engines");
+    const enginesRoot = join19(d.store.dir(), "engines");
     const items = catalogForPlatform().map((e) => {
       let installed;
       let enabled;
       if (e.provision === "pip") {
         const venvSubdir = e.id === "mlx" ? "mlx" : "vllm";
-        const pyPath = join17(
+        const pyPath = join19(
           enginesRoot,
           venvSubdir,
           "venv",
           process.platform === "win32" ? "Scripts/python.exe" : "bin/python"
         );
-        installed = existsSync15(pyPath);
+        installed = existsSync17(pyPath);
         enabled = regEngines.some((x) => x.kind === e.kind);
       } else if (e.id === "turboquant") {
-        const tqDir = join17(enginesRoot, "turboquant");
-        installed = existsSync15(tqDir);
+        const tqDir = join19(enginesRoot, "turboquant");
+        installed = existsSync17(tqDir);
         enabled = regEngines.some((x) => /[\\/]engines[\\/]turboquant[\\/]/.test(x.binPath));
       } else if (e.id === "koboldcpp") {
-        installed = existsSync15(koboldcppBinPath(enginesRoot));
+        installed = existsSync17(koboldcppBinPath(enginesRoot));
         enabled = regEngines.some((x) => x.kind === "koboldcpp");
       } else if (e.id === "llamafile") {
-        installed = existsSync15(llamafileBinPath(enginesRoot));
+        installed = existsSync17(llamafileBinPath(enginesRoot));
         enabled = regEngines.some((x) => x.kind === "llamafile");
       }
-      return { ...e, installed, enabled };
+      const srcEng = regEngines.find((x) => sameRepo(x.sourceRepo, e.homepage));
+      let sourceBinPath = srcEng?.binPath;
+      if (!srcEng) sourceBinPath = sourceBuildBinary(enginesRoot, e.homepage) ?? void 0;
+      const sourceBuilt = !!srcEng || !!sourceBinPath;
+      if (srcEng) {
+        installed = true;
+        enabled = true;
+      } else if (sourceBinPath) {
+        installed = true;
+        enabled = enabled ?? false;
+      }
+      return {
+        ...e,
+        installed,
+        enabled,
+        sourceBuilt,
+        sourceEngineId: srcEng?.id,
+        sourceBranch: srcEng?.sourceBranch ?? "",
+        sourceBinPath: sourceBinPath ?? ""
+      };
     });
     return c.json({ engines: items });
   });
@@ -8339,10 +8835,131 @@ function registerApi(app2, d) {
     const rec = recommendEngines(hw, catalogForPlatform().map(({ supportedHere, ...e }) => e));
     return c.json({ hardware: hw, recommendation: rec });
   });
-  app2.get("/api/v1/build/prereqs", async (c) => c.json(await checkBuildPrereqs()));
+  app2.get(
+    "/api/v1/build/prereqs",
+    async (c) => c.json(await checkBuildPrereqs(d.store.snapshot().build.toolchainDirs))
+  );
+  app2.post("/api/v1/build/run", async (c) => {
+    if (!isLocalRequest(c, d))
+      return err2(c, 403, "forbidden", "Building an engine is only available on the machine running TurboLLM.");
+    if (process.platform !== "win32")
+      return err2(c, 409, "unsupported_platform", "In-app build is currently Windows + CUDA only.");
+    const b = await body2(c);
+    const repoUrl = (b.repoUrl ?? "").trim();
+    if (!/^https?:\/\//i.test(repoUrl))
+      return err2(c, 400, "invalid_config_value", "A http(s) repo URL is required.");
+    const branch = (b.branch ?? "").trim() || void 0;
+    if (branch && branch.startsWith("-"))
+      return err2(c, 400, "invalid_config_value", 'Branch name cannot start with "-".');
+    const busy = engineWorkBusy(d);
+    if (busy) return err2(c, 409, "engine_already_running", busy);
+    const name = (b.name ?? "").trim() || void 0;
+    const enginesRoot = join19(d.store.dir(), "engines");
+    const toolchainDirs = d.store.snapshot().build.toolchainDirs;
+    const buildRoot = join19(enginesRoot, "build", buildDirName(repoUrl, branch));
+    const ac = new AbortController();
+    buildAbort = ac;
+    d.build.start(name ?? repoUrl);
+    void (async () => {
+      try {
+        let out;
+        try {
+          out = await runBuild(
+            { repoUrl, branch, enginesRoot, toolchainDirs },
+            { phase: (p) => d.build.phase(p), log: (line) => d.build.log(line) },
+            ac.signal
+          );
+        } catch (e) {
+          try {
+            rmSync10(buildRoot, { recursive: true, force: true });
+          } catch {
+          }
+          if (e?.name === "AbortError") {
+            d.build.log("Build cancelled.");
+            d.build.fail("Build cancelled.");
+          } else {
+            const asmIssue = d.build.get().log.some((l) => /No CMAKE_ASM_COMPILER could be found|ASM compiler identification is unknown/i.test(l));
+            const raw = e instanceof Error ? e.message : String(e);
+            d.build.fail(
+              asmIssue ? "This fork needs a GAS/MinGW assembler (it enables CMake's generic ASM language), which isn't available with the MSVC toolchain \u2014 so it can't be built here on Windows. Use a prebuilt binary, or build it under MSYS2/MinGW and add it via \u201CAdd your own engine.\u201D" : raw
+            );
+          }
+          return;
+        }
+        const engines = d.registry.list().engines;
+        const prior = engines.find((e) => e.binPath === out.binPath) ?? engines.find((e) => e.sourceRepo === repoUrl && (e.sourceBranch ?? "") === (branch ?? ""));
+        if (prior) {
+          if (d.registry.active()?.id === prior.id) await d.manager.stopAndWait();
+          try {
+            d.registry.remove(prior.id);
+          } catch {
+          }
+        }
+        const eng = (await d.registry.add(prior?.name ?? name ?? "", out.binPath, {
+          sourceRepo: repoUrl,
+          sourceBranch: branch
+        })).engine;
+        d.registry.activate(eng.id);
+        d.build.log(`Registered "${eng.name}" \u2014 built from ${out.commit.slice(0, 8)}.`);
+        d.build.done();
+      } catch (e) {
+        d.build.fail(`Built successfully, but couldn't register the engine: ${e instanceof Error ? e.message : String(e)}`);
+      } finally {
+        if (buildAbort === ac) buildAbort = null;
+      }
+    })();
+    return c.json({ accepted: true }, 202);
+  });
+  app2.post("/api/v1/build/cancel", (c) => {
+    if (buildAbort) {
+      buildAbort.abort();
+      return c.json({ ok: true });
+    }
+    return c.json({ ok: false });
+  });
+  app2.post("/api/v1/build/cuda", async (c) => {
+    if (!isLocalRequest(c, d))
+      return err2(c, 403, "forbidden", "Downloading CUDA is only available on the machine running TurboLLM.");
+    if (process.platform !== "win32")
+      return err2(c, 409, "unsupported_platform", "Automatic CUDA download is currently Windows x86_64 only.");
+    const busy = engineWorkBusy(d);
+    if (busy) return err2(c, 409, "engine_already_running", busy);
+    const dataDir = d.store.dir();
+    const ac = new AbortController();
+    buildAbort = ac;
+    d.build.start("CUDA Toolkit");
+    d.build.phase("provisioning");
+    void (async () => {
+      try {
+        const tk = await provisionCuda(
+          dataDir,
+          (p) => d.build.log(p.pct != null ? `${p.message} ${Math.round(p.pct * 100)}%` : p.message),
+          ac.signal
+        );
+        d.store.update((cfg2) => {
+          if (!cfg2.build.toolchainDirs.includes(tk.binDir)) cfg2.build.toolchainDirs.unshift(tk.binDir);
+        });
+        d.build.log(`CUDA ${tk.version} installed and added to your build environment.`);
+        d.build.done();
+      } catch (e) {
+        if (e?.name === "AbortError") {
+          d.build.log("CUDA download cancelled.");
+          d.build.fail("CUDA download cancelled.");
+        } else {
+          d.build.fail(`Could not download CUDA: ${e instanceof Error ? e.message : String(e)}`);
+        }
+      } finally {
+        if (buildAbort === ac) buildAbort = null;
+      }
+    })();
+    return c.json({ accepted: true }, 202);
+  });
   app2.post("/api/v1/engines/vllm", (c) => {
-    if (d.provision.get().active) return err2(c, 409, "engine_already_running", "Another engine download is already in progress.");
-    const root = join17(d.store.dir(), "engines");
+    {
+      const busy = engineWorkBusy(d);
+      if (busy) return err2(c, 409, "engine_already_running", busy);
+    }
+    const root = join19(d.store.dir(), "engines");
     const upgrade = c.req.query("update") === "1";
     void (async () => {
       try {
@@ -8363,15 +8980,18 @@ function registerApi(app2, d) {
     if (!entry.platforms.includes(process.platform)) {
       return err2(c, 409, "unsupported_platform", "TurboQuant has no prebuilt binary for this operating system yet.");
     }
-    if (d.provision.get().active) return err2(c, 409, "engine_already_running", "Another engine download is already in progress.");
-    const root = join17(d.store.dir(), "engines");
+    {
+      const busy = engineWorkBusy(d);
+      if (busy) return err2(c, 409, "engine_already_running", busy);
+    }
+    const root = join19(d.store.dir(), "engines");
     const upgrade = c.req.query("update") === "1";
     void (async () => {
       try {
         d.provision.start("turboquant");
         if (upgrade) {
-          const tqDir = join17(root, "turboquant");
-          if (existsSync15(tqDir)) rmSync8(tqDir, { recursive: true, force: true });
+          const tqDir = join19(root, "turboquant");
+          if (existsSync17(tqDir)) rmSync10(tqDir, { recursive: true, force: true });
         }
         const bin = await provisionTurboquant(
           root,
@@ -8395,8 +9015,11 @@ function registerApi(app2, d) {
     if (!entry.platforms.includes(process.platform)) {
       return err2(c, 409, "unsupported_platform", "KoboldCpp has no prebuilt binary for this operating system yet.");
     }
-    if (d.provision.get().active) return err2(c, 409, "engine_already_running", "Another engine download is already in progress.");
-    const root = join17(d.store.dir(), "engines");
+    {
+      const busy = engineWorkBusy(d);
+      if (busy) return err2(c, 409, "engine_already_running", busy);
+    }
+    const root = join19(d.store.dir(), "engines");
     const upgrade = c.req.query("update") === "1";
     const hasNvidia = primaryVendor(getSysInfo()) === "nvidia";
     void (async () => {
@@ -8404,7 +9027,7 @@ function registerApi(app2, d) {
         d.provision.start("koboldcpp");
         if (upgrade) {
           const dir = koboldcppDir(root);
-          if (existsSync15(dir)) rmSync8(dir, { recursive: true, force: true });
+          if (existsSync17(dir)) rmSync10(dir, { recursive: true, force: true });
         }
         const rt = await ensureKoboldcpp(root, hasNvidia, (p) => d.provision.progress(p.phase, p.pct, p.part, p.parts));
         const eng = d.registry.addKoboldcpp(`KoboldCpp (${rt.version})`, rt.binPath, rt.version);
@@ -8423,15 +9046,18 @@ function registerApi(app2, d) {
     if (!entry.platforms.includes(process.platform)) {
       return err2(c, 409, "unsupported_platform", "llamafile is not available for this operating system yet.");
     }
-    if (d.provision.get().active) return err2(c, 409, "engine_already_running", "Another engine download is already in progress.");
-    const root = join17(d.store.dir(), "engines");
+    {
+      const busy = engineWorkBusy(d);
+      if (busy) return err2(c, 409, "engine_already_running", busy);
+    }
+    const root = join19(d.store.dir(), "engines");
     const upgrade = c.req.query("update") === "1";
     void (async () => {
       try {
         d.provision.start("llamafile");
         if (upgrade) {
           const dir = llamafileDir(root);
-          if (existsSync15(dir)) rmSync8(dir, { recursive: true, force: true });
+          if (existsSync17(dir)) rmSync10(dir, { recursive: true, force: true });
         }
         const rt = await ensureLlamafile(root, (p) => d.provision.progress(p.phase, p.pct, p.part, p.parts));
         const eng = d.registry.addLlamafile(`llamafile (${rt.version})`, rt.binPath, rt.version);
@@ -8511,10 +9137,10 @@ function registerApi(app2, d) {
       const eng = d.registry.get(id);
       d.registry.remove(id);
       if (purge && eng) {
-        const enginesRoot = join17(d.store.dir(), "engines");
+        const enginesRoot = join19(d.store.dir(), "engines");
         const purgeDir = engineInstallDir(eng, enginesRoot);
-        if (purgeDir && existsSync15(purgeDir)) {
-          rmSync8(purgeDir, { recursive: true, force: true });
+        if (purgeDir && existsSync17(purgeDir)) {
+          rmSync10(purgeDir, { recursive: true, force: true });
         }
       }
       return c.json({ ok: true });
@@ -8594,21 +9220,21 @@ function registerApi(app2, d) {
     }
     let entries;
     try {
-      entries = readdirSync5(real, { withFileTypes: true }).filter((d2) => !d2.name.startsWith(".")).map((d2) => {
+      entries = readdirSync7(real, { withFileTypes: true }).filter((d2) => !d2.name.startsWith(".")).map((d2) => {
         let isDir = d2.isDirectory();
         if (d2.isSymbolicLink()) {
           try {
-            isDir = statSync5(join17(real, d2.name)).isDirectory();
+            isDir = statSync5(join19(real, d2.name)).isDirectory();
           } catch {
             isDir = false;
           }
         }
-        return { name: d2.name, path: join17(real, d2.name), isDir };
+        return { name: d2.name, path: join19(real, d2.name), isDir };
       }).sort((a, b) => a.isDir === b.isDir ? a.name.localeCompare(b.name) : a.isDir ? -1 : 1);
     } catch {
       return err2(c, 400, "fs_read_failed", "Could not read that folder (permission denied or not a directory).");
     }
-    const parentDir = real === home ? null : dirname6(real);
+    const parentDir = real === home ? null : dirname7(real);
     const parent = parentDir && isWithinHome(parentDir, home) ? parentDir : null;
     return c.json({ path: real, parent, entries });
   });
@@ -8703,22 +9329,22 @@ function registerApi(app2, d) {
     const raw = (b.path ?? "").trim();
     if (!raw) return err2(c, 400, "invalid_config_value", "Enter the path to your ComfyUI folder.");
     const root = resolve(raw);
-    if (!existsSync15(root) || !statSync5(root).isDirectory()) {
+    if (!existsSync17(root) || !statSync5(root).isDirectory()) {
       return err2(c, 400, "invalid_config_value", "That folder does not exist.");
     }
     let customNodes;
     if (basename3(root).toLowerCase() === "custom_nodes") customNodes = root;
-    else if (existsSync15(join17(root, "custom_nodes"))) customNodes = join17(root, "custom_nodes");
+    else if (existsSync17(join19(root, "custom_nodes"))) customNodes = join19(root, "custom_nodes");
     else {
       return err2(c, 400, "invalid_config_value", "No 'custom_nodes' folder here. Point me at your ComfyUI folder or its custom_nodes folder.");
     }
     const reqUrl = new URL(c.req.url);
     const port2 = reqUrl.port || (reqUrl.protocol === "https:" ? "443" : "80");
     const base2 = `http://127.0.0.1:${port2}`;
-    const gateDir = join17(customNodes, "turbollm_gate");
+    const gateDir = join19(customNodes, "turbollm_gate");
     try {
-      mkdirSync10(gateDir, { recursive: true });
-      writeFileSync7(join17(gateDir, "__init__.py"), gateNodeSource(base2));
+      mkdirSync12(gateDir, { recursive: true });
+      writeFileSync8(join19(gateDir, "__init__.py"), gateNodeSource(base2));
     } catch (e) {
       return err2(c, 500, "fs_write_failed", `Could not write the gate node: ${e instanceof Error ? e.message : e}`);
     }
@@ -8729,9 +9355,9 @@ function registerApi(app2, d) {
   });
   app2.post("/api/v1/comfyui/uninstall", (c) => {
     const dir = d.store.snapshot().comfyui.gatePath;
-    if (dir && existsSync15(dir)) {
+    if (dir && existsSync17(dir)) {
       try {
-        rmSync8(dir, { recursive: true, force: true });
+        rmSync10(dir, { recursive: true, force: true });
       } catch (e) {
         return err2(c, 500, "fs_write_failed", `Could not remove the gate node: ${e instanceof Error ? e.message : e}`);
       }
@@ -8764,8 +9390,8 @@ function registerApi(app2, d) {
       });
       while (!aborted) {
         const path = d.manager.logPath();
-        if (path && existsSync15(path)) {
-          const lines = readFileSync7(path, "utf8").split("\n");
+        if (path && existsSync17(path)) {
+          const lines = readFileSync8(path, "utf8").split("\n");
           for (; sent < lines.length - 1; sent++) {
             await stream.writeSSE({ event: "line", data: JSON.stringify({ line: lines[sent].replace(/\r$/, "") }) });
           }
@@ -8938,12 +9564,26 @@ function registerApi(app2, d) {
       if (!Number.isInteger(v) || v < 1 || v > 4) return err2(c, 400, "invalid_config_value", "gateway.keepN must be 1\u20134.");
       gwUpdates.keepN = v;
     }
+    let toolchainDirs;
+    if (b.build?.toolchainDirs !== void 0) {
+      if (!Array.isArray(b.build.toolchainDirs)) {
+        return err2(c, 400, "invalid_config_value", "build.toolchainDirs must be an array of paths.");
+      }
+      const dirs = b.build.toolchainDirs.map((p) => String(p).trim()).filter(Boolean);
+      for (const dir of dirs) {
+        if (!/^([a-zA-Z]:[\\/]|[\\/])/.test(dir)) {
+          return err2(c, 400, "invalid_config_value", `build.toolchainDirs: "${dir}" must be an absolute path.`);
+        }
+      }
+      toolchainDirs = dirs;
+    }
     const before = d.store.snapshot().daemon;
     d.store.update((cfg2) => {
       Object.assign(cfg2.daemon, updates2);
       Object.assign(cfg2.modelDefaults, mdUpdates);
       Object.assign(cfg2.comfyui, cuUpdates);
       Object.assign(cfg2.gateway, gwUpdates);
+      if (toolchainDirs !== void 0) cfg2.build.toolchainDirs = toolchainDirs;
       if (b.autoLoadOnStart !== void 0) cfg2.autoLoadOnStart = !!b.autoLoadOnStart;
       if (telemetryLevel !== void 0) cfg2.telemetry.level = telemetryLevel;
       if (b.hfToken !== void 0) cfg2.hf.token = String(b.hfToken).trim();
@@ -9047,7 +9687,7 @@ function registerApi(app2, d) {
     const b = await body2(c);
     const dir = (b.dir ?? "").trim();
     if (!dir || !/^([a-zA-Z]:[\\/]|[\\/])/.test(dir)) return err2(c, 400, "invalid_config_value", "Path must be absolute.");
-    if (!existsSync15(dir)) return err2(c, 400, "invalid_config_value", "That folder does not exist.");
+    if (!existsSync17(dir)) return err2(c, 400, "invalid_config_value", "That folder does not exist.");
     try {
       d.store.update((cfg2) => {
         if (!cfg2.modelDirs.includes(dir)) cfg2.modelDirs.push(dir);
@@ -9277,7 +9917,10 @@ function settingsPayload(d) {
       kagiKeySet: !!cfg2.tools.search?.kagiApiKey,
       searxngUrl: cfg2.tools.search?.searxngUrl ?? ""
     },
-    mcp: cfg2.mcp
+    mcp: cfg2.mcp,
+    // Build environment (ADR-100): folders prepended to PATH for compile-from-source so a
+    // conda-env / custom-path CUDA Toolkit + compiler are found. Not secret — echoed back.
+    build: { toolchainDirs: cfg2.build.toolchainDirs }
   };
 }
 function telemetryPreview(level, version2) {
@@ -9332,6 +9975,11 @@ function localCountFor(d, repo) {
   }
   return n;
 }
+function engineWorkBusy(d) {
+  if (d.provision.get().active) return "An engine download is in progress \u2014 wait for it to finish.";
+  if (d.build.isActive()) return "A build is in progress \u2014 wait for it to finish.";
+  return null;
+}
 function hfErr(c, e) {
   if (e instanceof HfError) {
     const status = e.code === "hf_unauthorized" ? 401 : e.code === "hf_gated" ? 403 : e.code === "hf_not_found" ? 404 : 503;
@@ -9369,15 +10017,15 @@ function engineInstallDir(eng, enginesRoot) {
     return n.startsWith(norm + "/") || n.startsWith(norm + "\\");
   };
   if (eng.kind === "mlx") {
-    const d = join17(enginesRoot, "mlx", "venv");
+    const d = join19(enginesRoot, "mlx", "venv");
     return inside(d) ? d : null;
   }
   if (eng.kind === "vllm") {
-    const d = join17(enginesRoot, "vllm", "venv");
+    const d = join19(enginesRoot, "vllm", "venv");
     return inside(d) ? d : null;
   }
   if (/[\\/]engines[\\/]turboquant[\\/]/.test(eng.binPath)) {
-    const d = join17(enginesRoot, "turboquant");
+    const d = join19(enginesRoot, "turboquant");
     return inside(d) ? d : null;
   }
   if (eng.kind === "koboldcpp") {
@@ -9388,6 +10036,13 @@ function engineInstallDir(eng, enginesRoot) {
     const d = llamafileDir(enginesRoot);
     return inside(d) ? d : null;
   }
+  const srcDir = sourceBuildDirOf(eng.binPath, enginesRoot);
+  if (srcDir) return inside(srcDir) ? srcDir : null;
+  const llamaMatch = eng.binPath.replace(/\\/g, "/").match(/\/(llama\.cpp-[^/]+)\//i);
+  if (llamaMatch) {
+    const d = join19(enginesRoot, llamaMatch[1]);
+    return inside(d) ? d : null;
+  }
   return null;
 }
 function deriveModel(modelPath, name, extraArgs) {
@@ -9401,9 +10056,9 @@ function cleanModelName(p) {
   return basename3(p).replace(/\.gguf$/i, "");
 }
 function readTail2(path, n) {
-  if (!path || !existsSync15(path)) return [];
+  if (!path || !existsSync17(path)) return [];
   try {
-    const lines = readFileSync7(path, "utf8").replace(/[\r\n]+$/, "").split("\n").map((l) => l.replace(/\r$/, ""));
+    const lines = readFileSync8(path, "utf8").replace(/[\r\n]+$/, "").split("\n").map((l) => l.replace(/\r$/, ""));
     return lines.length > n ? lines.slice(-n) : lines;
   } catch {
     return [];
@@ -10094,7 +10749,7 @@ async function recordOpenAiStreamUsage(d, body3) {
 
 // src/server.ts
 setGlobalDispatcher(new Agent({ keepAliveMaxTimeout: 6e4, connections: 10 }));
-var WEB_ROOT = join18(dirname7(fileURLToPath(import.meta.url)), "webdist");
+var WEB_ROOT = join20(dirname8(fileURLToPath(import.meta.url)), "webdist");
 function createApp(d) {
   const app2 = new Hono();
   app2.use(
@@ -10119,12 +10774,12 @@ function createApp(d) {
     if (path.startsWith("api/") || path.startsWith("v1/")) {
       return c.json({ error: { code: "not_found", message: "Unknown endpoint." } }, 404);
     }
-    let file = normalize2(join18(WEB_ROOT, path || "index.html"));
-    if (!file.startsWith(WEB_ROOT) || !existsSync16(file) || statSync6(file).isDirectory()) {
-      file = join18(WEB_ROOT, "index.html");
+    let file = normalize2(join20(WEB_ROOT, path || "index.html"));
+    if (!file.startsWith(WEB_ROOT) || !existsSync18(file) || statSync6(file).isDirectory()) {
+      file = join20(WEB_ROOT, "index.html");
     }
-    if (!existsSync16(file)) return c.text("web ui not built \u2014 run `npm run build:web`", 500);
-    return new Response(readFileSync8(file), { status: 200, headers: { "Content-Type": contentType(file) } });
+    if (!existsSync18(file)) return c.text("web ui not built \u2014 run `npm run build:web`", 500);
+    return new Response(readFileSync9(file), { status: 200, headers: { "Content-Type": contentType(file) } });
   });
   return app2;
 }
@@ -10151,8 +10806,8 @@ function contentType(file) {
 // src/cli.ts
 var version = "0.1.1";
 try {
-  const pkgPath = join19(dirname8(fileURLToPath2(import.meta.url)), "..", "package.json");
-  version = JSON.parse(readFileSync9(pkgPath, "utf8")).version ?? version;
+  const pkgPath = join21(dirname9(fileURLToPath2(import.meta.url)), "..", "package.json");
+  version = JSON.parse(readFileSync10(pkgPath, "utf8")).version ?? version;
 } catch {
 }
 var nodeMajor = Number(process.versions.node.split(".")[0]);
@@ -10227,8 +10882,9 @@ var registry = new Registry(store);
 var pruned = registry.pruneDeadManagedBuilds();
 if (pruned > 0) console.log(`pruned ${pruned} dangling engine build(s)`);
 var provision = new ProvisionState();
+var build = new BuildState();
 var updates = new UpdateChecker();
-var enginesDir = join19(store.dir(), "engines");
+var enginesDir = join21(store.dir(), "engines");
 void seedDefaultEngines(registry, enginesDir, provision).then(() => registry.ensureProbed());
 var manager = new Manager(store);
 var scanner = new Scanner(store);
@@ -10248,7 +10904,7 @@ void (async () => {
 })();
 var startedAt = Date.now();
 var appUpdates = new AppUpdateChecker(version);
-var deps = { store, registry, manager, scanner, hashes, db, provision, updates, appUpdates, hf, downloads, bench, modelRouter, comfy, tools: toolRegistry, version, startedAt };
+var deps = { store, registry, manager, scanner, hashes, db, provision, build, updates, appUpdates, hf, downloads, bench, modelRouter, comfy, tools: toolRegistry, version, startedAt };
 var app = createApp(deps);
 setTimeout(() => void appUpdates.check(AbortSignal.timeout(1e4)).catch(() => {
 }), 5e3).unref();
@@ -10288,7 +10944,7 @@ function openBrowser(url) {
     cmd = "xdg-open";
     args = [url];
   }
-  const child = spawn4(cmd, args, { detached: true, stdio: "ignore" });
+  const child = spawn5(cmd, args, { detached: true, stdio: "ignore" });
   child.unref();
   child.on("error", () => {
     console.log(`  Could not open browser automatically. Visit the URL above manually.`);
@@ -10375,11 +11031,11 @@ var restarting = false;
 function spawnReplacement() {
   let out = "ignore";
   try {
-    out = openSync3(join19(store.dir(), "restart.log"), "a");
+    out = openSync3(join21(store.dir(), "restart.log"), "a");
   } catch {
     out = "ignore";
   }
-  const child = spawn4(process.execPath, process.argv.slice(1), {
+  const child = spawn5(process.execPath, process.argv.slice(1), {
     cwd: process.cwd(),
     detached: true,
     stdio: ["ignore", out, out]