@vercel/python 6.3.2 → 6.4.0

package/dist/index.js

@@ -48,7 +48,7 @@ var require_windows = __commonJS({
   "../../node_modules/.pnpm/isexe@2.0.0/node_modules/isexe/windows.js"(exports, module2) {
     module2.exports = isexe;
     isexe.sync = sync;
-    var fs4 = require("fs");
+    var fs5 = require("fs");
     function checkPathExt(path, options) {
       var pathext = options.pathExt !== void 0 ? options.pathExt : process.env.PATHEXT;
       if (!pathext) {
@@ -73,12 +73,12 @@ var require_windows = __commonJS({
       return checkPathExt(path, options);
     }
     function isexe(path, options, cb) {
-      fs4.stat(path, function(er, stat) {
+      fs5.stat(path, function(er, stat) {
         cb(er, er ? false : checkStat(stat, path, options));
       });
     }
     function sync(path, options) {
-      return checkStat(fs4.statSync(path), path, options);
+      return checkStat(fs5.statSync(path), path, options);
     }
   }
 });
@@ -88,14 +88,14 @@ var require_mode = __commonJS({
   "../../node_modules/.pnpm/isexe@2.0.0/node_modules/isexe/mode.js"(exports, module2) {
     module2.exports = isexe;
     isexe.sync = sync;
-    var fs4 = require("fs");
+    var fs5 = require("fs");
     function isexe(path, options, cb) {
-      fs4.stat(path, function(er, stat) {
+      fs5.stat(path, function(er, stat) {
         cb(er, er ? false : checkStat(stat, options));
       });
     }
     function sync(path, options) {
-      return checkStat(fs4.statSync(path), options);
+      return checkStat(fs5.statSync(path), options);
     }
     function checkStat(stat, options) {
       return stat.isFile() && checkMode(stat, options);
@@ -119,7 +119,7 @@ var require_mode = __commonJS({
 // ../../node_modules/.pnpm/isexe@2.0.0/node_modules/isexe/index.js
 var require_isexe = __commonJS({
   "../../node_modules/.pnpm/isexe@2.0.0/node_modules/isexe/index.js"(exports, module2) {
-    var fs4 = require("fs");
+    var fs5 = require("fs");
     var core;
     if (process.platform === "win32" || global.TESTING_WINDOWS) {
       core = require_windows();
@@ -174,8 +174,8 @@ var require_isexe = __commonJS({
 // ../../node_modules/.pnpm/which@1.3.1/node_modules/which/which.js
 var require_which = __commonJS({
   "../../node_modules/.pnpm/which@1.3.1/node_modules/which/which.js"(exports, module2) {
-    module2.exports = which3;
-    which3.sync = whichSync;
+    module2.exports = which2;
+    which2.sync = whichSync;
     var isWindows = process.platform === "win32" || process.env.OSTYPE === "cygwin" || process.env.OSTYPE === "msys";
     var path = require("path");
     var COLON = isWindows ? ";" : ":";
@@ -206,7 +206,7 @@ var require_which = __commonJS({
         extExe: pathExtExe
       };
     }
-    function which3(cmd, opt, cb) {
+    function which2(cmd, opt, cb) {
       if (typeof opt === "function") {
         cb = opt;
         opt = {};
@@ -307,7 +307,7 @@ var require_resolveCommand = __commonJS({
   "../../node_modules/.pnpm/cross-spawn@6.0.5/node_modules/cross-spawn/lib/util/resolveCommand.js"(exports, module2) {
     "use strict";
     var path = require("path");
-    var which3 = require_which();
+    var which2 = require_which();
     var pathKey = require_path_key()();
     function resolveCommandAttempt(parsed, withoutPathExt) {
       const cwd = process.cwd();
@@ -320,7 +320,7 @@ var require_resolveCommand = __commonJS({
       }
       let resolved;
       try {
-        resolved = which3.sync(parsed.command, {
+        resolved = which2.sync(parsed.command, {
           path: (parsed.options.env || process.env)[pathKey],
           pathExt: withoutPathExt ? path.delimiter : void 0
         });
@@ -395,7 +395,7 @@ var require_shebang_command = __commonJS({
 var require_readShebang = __commonJS({
   "../../node_modules/.pnpm/cross-spawn@6.0.5/node_modules/cross-spawn/lib/util/readShebang.js"(exports, module2) {
     "use strict";
-    var fs4 = require("fs");
+    var fs5 = require("fs");
     var shebangCommand = require_shebang_command();
     function readShebang(command) {
       const size = 150;
@@ -408,9 +408,9 @@ var require_readShebang = __commonJS({
       }
       let fd;
       try {
-        fd = fs4.openSync(command, "r");
-        fs4.readSync(fd, buffer, 0, size, 0);
-        fs4.closeSync(fd);
+        fd = fs5.openSync(command, "r");
+        fs5.readSync(fd, buffer, 0, size, 0);
+        fs5.closeSync(fd);
       } catch (e) {
       }
       return shebangCommand(buffer.toString());
@@ -1498,7 +1498,7 @@ var require_parse = __commonJS({
     var escape = require_escape();
     var readShebang = require_readShebang();
     var semver = require_semver();
-    var isWin3 = process.platform === "win32";
+    var isWin4 = process.platform === "win32";
     var isExecutableRegExp = /\.(?:com|exe)$/i;
     var isCmdShimRegExp = /node_modules[\\/].bin[\\/][^\\/]+\.cmd$/i;
     var supportsShellOption = niceTry(() => semver.satisfies(process.version, "^4.8.0 || ^5.7.0 || >= 6.0.0", true)) || false;
@@ -1513,7 +1513,7 @@ var require_parse = __commonJS({
       return parsed.file;
     }
     function parseNonShell(parsed) {
-      if (!isWin3) {
+      if (!isWin4) {
         return parsed;
       }
       const commandFile = detectShebang(parsed);
@@ -1535,7 +1535,7 @@ var require_parse = __commonJS({
         return parsed;
       }
       const shellCommand = [parsed.command].concat(parsed.args).join(" ");
-      if (isWin3) {
+      if (isWin4) {
         parsed.command = typeof parsed.options.shell === "string" ? parsed.options.shell : process.env.comspec || "cmd.exe";
         parsed.args = ["/d", "/s", "/c", `"${shellCommand}"`];
         parsed.options.windowsVerbatimArguments = true;
@@ -1578,7 +1578,7 @@ var require_parse = __commonJS({
 var require_enoent = __commonJS({
   "../../node_modules/.pnpm/cross-spawn@6.0.5/node_modules/cross-spawn/lib/enoent.js"(exports, module2) {
     "use strict";
-    var isWin3 = process.platform === "win32";
+    var isWin4 = process.platform === "win32";
     function notFoundError(original, syscall) {
       return Object.assign(new Error(`${syscall} ${original.command} ENOENT`), {
         code: "ENOENT",
@@ -1589,7 +1589,7 @@ var require_enoent = __commonJS({
       });
     }
     function hookChildProcess(cp, parsed) {
-      if (!isWin3) {
+      if (!isWin4) {
         return;
       }
       const originalEmit = cp.emit;
@@ -1604,13 +1604,13 @@ var require_enoent = __commonJS({
       };
     }
     function verifyENOENT(status, parsed) {
-      if (isWin3 && status === 1 && !parsed.file) {
+      if (isWin4 && status === 1 && !parsed.file) {
         return notFoundError(parsed.original, "spawn");
       }
       return null;
     }
     function verifyENOENTSync(status, parsed) {
-      if (isWin3 && status === 1 && !parsed.file) {
+      if (isWin4 && status === 1 && !parsed.file) {
         return notFoundError(parsed.original, "spawnSync");
       }
       return null;
@@ -1895,9 +1895,9 @@ var require_pump = __commonJS({
   "../../node_modules/.pnpm/pump@3.0.2/node_modules/pump/index.js"(exports, module2) {
     var once = require_once();
     var eos = require_end_of_stream();
-    var fs4;
+    var fs5;
     try {
-      fs4 = require("fs");
+      fs5 = require("fs");
     } catch (e) {
     }
     var noop = function() {
@@ -1909,9 +1909,9 @@ var require_pump = __commonJS({
     var isFS = function(stream) {
       if (!ancient)
         return false;
-      if (!fs4)
+      if (!fs5)
         return false;
-      return (stream instanceof (fs4.ReadStream || noop) || stream instanceof (fs4.WriteStream || noop)) && isFn(stream.close);
+      return (stream instanceof (fs5.ReadStream || noop) || stream instanceof (fs5.WriteStream || noop)) && isFn(stream.close);
     };
     var isRequest = function(stream) {
       return stream.setHeader && isFn(stream.abort);
@@ -2143,7 +2143,7 @@ var require_signal_exit = __commonJS({
     } else {
       assert = require("assert");
       signals = require_signals();
-      isWin3 = /^win/i.test(process2.platform);
+      isWin4 = /^win/i.test(process2.platform);
       EE = require("events");
       if (typeof EE !== "function") {
         EE = EE.EventEmitter;
@@ -2215,7 +2215,7 @@ var require_signal_exit = __commonJS({
             unload();
             emit("exit", null, sig);
             emit("afterexit", null, sig);
-            if (isWin3 && sig === "SIGHUP") {
+            if (isWin4 && sig === "SIGHUP") {
               sig = "SIGINT";
             }
             process2.kill(process2.pid, sig);
@@ -2272,7 +2272,7 @@ var require_signal_exit = __commonJS({
     }
     var assert;
     var signals;
-    var isWin3;
+    var isWin4;
     var EE;
     var emitter;
     var unload;
@@ -2651,7 +2651,7 @@ ${stderr}${stdout}`;
 var require_lib = __commonJS({
   "../../node_modules/.pnpm/which@3.0.0/node_modules/which/lib/index.js"(exports, module2) {
     var isexe = require_isexe();
-    var { join: join6, delimiter, sep, posix } = require("path");
+    var { join: join7, delimiter, sep, posix } = require("path");
     var isWindows = process.platform === "win32";
     var rSlash = new RegExp(`[${posix.sep}${sep === posix.sep ? "" : sep}]`.replace(/(\\)/g, "\\$1"));
     var rRel = new RegExp(`^\\.${rSlash.source}`);
@@ -2680,9 +2680,9 @@ var require_lib = __commonJS({
     var getPathPart = (raw, cmd) => {
       const pathPart = /^".*"$/.test(raw) ? raw.slice(1, -1) : raw;
       const prefix = !pathPart && rRel.test(cmd) ? cmd.slice(0, 2) : "";
-      return prefix + join6(pathPart, cmd);
+      return prefix + join7(pathPart, cmd);
     };
-    var which3 = async (cmd, opt = {}) => {
+    var which2 = async (cmd, opt = {}) => {
       const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
       const found = [];
       for (const envPart of pathEnv) {
@@ -2730,8 +2730,8 @@ var require_lib = __commonJS({
       }
       throw getNotFoundError(cmd);
     };
-    module2.exports = which3;
-    which3.sync = whichSync;
+    module2.exports = which2;
+    which2.sync = whichSync;
   }
 });
 
@@ -2748,55 +2748,279 @@ __export(src_exports, {
   version: () => version
 });
 module.exports = __toCommonJS(src_exports);
-var import_fs4 = __toESM(require("fs"));
+var import_fs5 = __toESM(require("fs"));
 var import_util = require("util");
-var import_path5 = require("path");
-var import_build_utils7 = require("@vercel/build-utils");
+var import_path7 = require("path");
+var import_build_utils8 = require("@vercel/build-utils");
 
 // src/install.ts
-var import_execa2 = __toESM(require_execa());
+var import_execa3 = __toESM(require_execa());
+var import_fs3 = __toESM(require("fs"));
+var import_os2 = __toESM(require("os"));
+var import_path4 = require("path");
+var import_build_utils4 = require("@vercel/build-utils");
+
+// src/utils.ts
 var import_fs2 = __toESM(require("fs"));
-var import_os = __toESM(require("os"));
-var import_path2 = require("path");
-var import_which = __toESM(require_lib());
+var import_path3 = require("path");
 var import_build_utils2 = require("@vercel/build-utils");
+var import_execa2 = __toESM(require_execa());
 
-// src/utils.ts
-var import_fs = __toESM(require("fs"));
+// src/uv.ts
+var import_child_process = require("child_process");
 var import_path = require("path");
-var import_build_utils = require("@vercel/build-utils");
+var import_path2 = require("path");
 var import_execa = __toESM(require_execa());
-var isWin = process.platform === "win32";
+var import_fs = __toESM(require("fs"));
+var import_os = __toESM(require("os"));
+var import_which = __toESM(require_lib());
+var import_build_utils = require("@vercel/build-utils");
+var UV_VERSION = "0.9.22";
+var UV_PYTHON_PATH_PREFIX = "/uv/python/";
 var UV_PYTHON_DOWNLOADS_MODE = "automatic";
+var isWin = process.platform === "win32";
+var uvExec = isWin ? "uv.exe" : "uv";
+function findUvInPath() {
+  return import_which.default.sync("uv", { nothrow: true });
+}
+var UvRunner = class {
+  constructor(uvPath) {
+    this.uvPath = uvPath;
+  }
+  getPath() {
+    return this.uvPath;
+  }
+  /**
+   * List installed Python versions managed by uv.
+   * Excludes system Python.
+   */
+  listInstalledPythons() {
+    let output;
+    try {
+      output = (0, import_child_process.execSync)(
+        `${this.uvPath} python list --only-installed --output-format json`,
+        { encoding: "utf8", stdio: ["pipe", "pipe", "pipe"] }
+      );
+    } catch (err) {
+      throw new Error(
+        `Failed to run 'uv python list': ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+    if (!output || output.trim() === "" || output.trim() === "[]") {
+      return /* @__PURE__ */ new Set();
+    }
+    let pyList;
+    try {
+      pyList = JSON.parse(output);
+    } catch (err) {
+      throw new Error(
+        `Failed to parse 'uv python list' output: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+    return new Set(
+      pyList.filter(
+        (entry) => entry.path !== null && entry.path.startsWith(UV_PYTHON_PATH_PREFIX) && entry.implementation === "cpython"
+      ).map(
+        (entry) => `${entry.version_parts.major}.${entry.version_parts.minor}`
+      )
+    );
+  }
+  async sync(options) {
+    const { venvPath, projectDir, locked } = options;
+    const args = ["sync", "--active", "--no-dev", "--link-mode", "copy"];
+    if (locked) {
+      args.push("--locked");
+    }
+    args.push("--no-editable");
+    await this.runUvCmd(args, projectDir, venvPath);
+  }
+  async lock(projectDir) {
+    const args = ["lock"];
+    const pretty = `uv ${args.join(" ")}`;
+    (0, import_build_utils.debug)(`Running "${pretty}" in ${projectDir}...`);
+    try {
+      await (0, import_execa.default)(this.uvPath, args, {
+        cwd: projectDir,
+        env: getProtectedUvEnv(process.env)
+      });
+    } catch (err) {
+      throw new Error(
+        `Failed to run "${pretty}": ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  }
+  async addDependencies(options) {
+    const { venvPath, projectDir, dependencies } = options;
+    const toAdd = dependencies.filter(Boolean);
+    if (!toAdd.length)
+      return;
+    const args = ["add", "--active", ...toAdd];
+    (0, import_build_utils.debug)(`Running "uv ${args.join(" ")}" in ${projectDir}...`);
+    await this.runUvCmd(args, projectDir, venvPath);
+  }
+  async addFromFile(options) {
+    const { venvPath, projectDir, requirementsPath } = options;
+    const args = ["add", "--active", "-r", requirementsPath];
+    (0, import_build_utils.debug)(`Running "uv ${args.join(" ")}" in ${projectDir}...`);
+    await this.runUvCmd(args, projectDir, venvPath);
+  }
+  async runUvCmd(args, cwd, venvPath) {
+    const pretty = `uv ${args.join(" ")}`;
+    (0, import_build_utils.debug)(`Running "${pretty}"...`);
+    try {
+      await (0, import_execa.default)(this.uvPath, args, {
+        cwd,
+        env: this.getVenvEnv(venvPath)
+      });
+    } catch (err) {
+      throw new Error(
+        `Failed to run "${pretty}": ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  }
+  getVenvEnv(venvPath) {
+    const binDir = isWin ? (0, import_path.join)(venvPath, "Scripts") : (0, import_path.join)(venvPath, "bin");
+    const existingPath = process.env.PATH || "";
+    return {
+      ...getProtectedUvEnv(process.env),
+      VIRTUAL_ENV: venvPath,
+      PATH: existingPath ? `${binDir}${import_path2.delimiter}${existingPath}` : binDir
+    };
+  }
+};
+async function getGlobalScriptsDir(pythonPath) {
+  const code = `import sysconfig; print(sysconfig.get_path('scripts'))`;
+  try {
+    const { stdout } = await (0, import_execa.default)(pythonPath, ["-c", code]);
+    const out = stdout.trim();
+    return out || null;
+  } catch (err) {
+    (0, import_build_utils.debug)("Failed to resolve Python global scripts directory", err);
+    return null;
+  }
+}
+async function getUserScriptsDir(pythonPath) {
+  const code = `import sys, sysconfig; print(sysconfig.get_path('scripts', scheme=('nt_user' if sys.platform == 'win32' else 'posix_user')))`.replace(
+    /\n/g,
+    " "
+  );
+  try {
+    const { stdout } = await (0, import_execa.default)(pythonPath, ["-c", code]);
+    const out = stdout.trim();
+    return out || null;
+  } catch (err) {
+    (0, import_build_utils.debug)("Failed to resolve Python user scripts directory", err);
+    return null;
+  }
+}
+async function findUvBinary(pythonPath) {
+  const found = import_which.default.sync("uv", { nothrow: true });
+  if (found)
+    return found;
+  try {
+    const globalScriptsDir = await getGlobalScriptsDir(pythonPath);
+    if (globalScriptsDir) {
+      const uvPath = (0, import_path.join)(globalScriptsDir, uvExec);
+      if (import_fs.default.existsSync(uvPath))
+        return uvPath;
+    }
+  } catch (err) {
+    (0, import_build_utils.debug)("Failed to resolve Python global scripts directory", err);
+  }
+  try {
+    const userScriptsDir = await getUserScriptsDir(pythonPath);
+    if (userScriptsDir) {
+      const uvPath = (0, import_path.join)(userScriptsDir, uvExec);
+      if (import_fs.default.existsSync(uvPath))
+        return uvPath;
+    }
+  } catch (err) {
+    (0, import_build_utils.debug)("Failed to resolve Python user scripts directory", err);
+  }
+  try {
+    const candidates = [];
+    if (!isWin) {
+      candidates.push((0, import_path.join)(import_os.default.homedir(), ".local", "bin", "uv"));
+      candidates.push("/usr/local/bin/uv");
+      candidates.push("/opt/homebrew/bin/uv");
+    } else {
+      candidates.push("C:\\Users\\Public\\uv\\uv.exe");
+    }
+    for (const p of candidates) {
+      if (import_fs.default.existsSync(p))
+        return p;
+    }
+  } catch (err) {
+    (0, import_build_utils.debug)("Failed to resolve uv fallback paths", err);
+  }
+  return null;
+}
+async function getUvBinaryOrInstall(pythonPath) {
+  const uvBin = await findUvBinary(pythonPath);
+  if (uvBin)
+    return uvBin;
+  try {
+    console.log("Installing uv...");
+    await (0, import_execa.default)(
+      pythonPath,
+      [
+        "-m",
+        "pip",
+        "install",
+        "--disable-pip-version-check",
+        "--no-cache-dir",
+        "--user",
+        `uv==${UV_VERSION}`
+      ],
+      { env: { ...process.env, PIP_USER: "1" } }
+    );
+  } catch (err) {
+    throw new Error(
+      `Failed to install uv via pip: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+  const resolvedUvBin = await findUvBinary(pythonPath);
+  if (!resolvedUvBin) {
+    throw new Error("Unable to resolve uv binary after pip install");
+  }
+  console.log(`Installed uv at "${resolvedUvBin}"`);
+  return resolvedUvBin;
+}
+function filterUnsafeUvPipArgs(args) {
+  return args.filter((arg) => arg !== "--no-warn-script-location");
+}
+function getProtectedUvEnv(baseEnv = process.env) {
+  return {
+    ...baseEnv,
+    UV_PYTHON_DOWNLOADS: UV_PYTHON_DOWNLOADS_MODE
+  };
+}
+
+// src/utils.ts
+var isWin2 = process.platform === "win32";
 var isInVirtualEnv = () => {
   return process.env.VIRTUAL_ENV;
 };
 function getVenvBinDir(venvPath) {
-  return (0, import_path.join)(venvPath, isWin ? "Scripts" : "bin");
+  return (0, import_path3.join)(venvPath, isWin2 ? "Scripts" : "bin");
 }
 function useVirtualEnv(workPath, env, systemPython) {
   const venvDirs = [".venv", "venv"];
   let pythonCmd = systemPython;
   for (const venv of venvDirs) {
-    const venvRoot = (0, import_path.join)(workPath, venv);
-    const binDir = process.platform === "win32" ? (0, import_path.join)(venvRoot, "Scripts") : (0, import_path.join)(venvRoot, "bin");
-    const candidates = process.platform === "win32" ? [(0, import_path.join)(binDir, "python.exe"), (0, import_path.join)(binDir, "python")] : [(0, import_path.join)(binDir, "python3"), (0, import_path.join)(binDir, "python")];
-    const found = candidates.find((p) => import_fs.default.existsSync(p));
+    const venvRoot = (0, import_path3.join)(workPath, venv);
+    const binDir = process.platform === "win32" ? (0, import_path3.join)(venvRoot, "Scripts") : (0, import_path3.join)(venvRoot, "bin");
+    const candidates = process.platform === "win32" ? [(0, import_path3.join)(binDir, "python.exe"), (0, import_path3.join)(binDir, "python")] : [(0, import_path3.join)(binDir, "python3"), (0, import_path3.join)(binDir, "python")];
+    const found = candidates.find((p) => import_fs2.default.existsSync(p));
     if (found) {
       pythonCmd = found;
       env.VIRTUAL_ENV = venvRoot;
-      env.PATH = `${binDir}${import_path.delimiter}${env.PATH || ""}`;
+      env.PATH = `${binDir}${import_path3.delimiter}${env.PATH || ""}`;
       return { pythonCmd, venvRoot };
     }
   }
   return { pythonCmd };
 }
-function getProtectedUvEnv(baseEnv = process.env) {
-  return {
-    ...baseEnv,
-    UV_PYTHON_DOWNLOADS: UV_PYTHON_DOWNLOADS_MODE
-  };
-}
 function createVenvEnv(venvPath, baseEnv = process.env) {
   const env = {
     ...getProtectedUvEnv(baseEnv),
@@ -2804,118 +3028,345 @@ function createVenvEnv(venvPath, baseEnv = process.env) {
   };
   const binDir = getVenvBinDir(venvPath);
   const existingPath = env.PATH || process.env.PATH || "";
-  env.PATH = existingPath ? `${binDir}${import_path.delimiter}${existingPath}` : binDir;
+  env.PATH = existingPath ? `${binDir}${import_path3.delimiter}${existingPath}` : binDir;
   return env;
 }
 async function ensureVenv({
   pythonPath,
   venvPath
 }) {
-  const marker = (0, import_path.join)(venvPath, "pyvenv.cfg");
+  const marker = (0, import_path3.join)(venvPath, "pyvenv.cfg");
   try {
-    await import_fs.default.promises.access(marker);
+    await import_fs2.default.promises.access(marker);
     return;
   } catch {
   }
-  await import_fs.default.promises.mkdir(venvPath, { recursive: true });
-  console.log(`Creating virtual environment at "${venvPath}"...`);
-  await (0, import_execa.default)(pythonPath, ["-m", "venv", venvPath]);
-}
-function getVenvPythonBin(venvPath) {
-  return (0, import_path.join)(getVenvBinDir(venvPath), isWin ? "python.exe" : "python");
+  await import_fs2.default.promises.mkdir(venvPath, { recursive: true });
+  console.log(`Creating virtual environment at "${venvPath}"...`);
+  await (0, import_execa2.default)(pythonPath, ["-m", "venv", venvPath]);
+}
+function getVenvPythonBin(venvPath) {
+  return (0, import_path3.join)(getVenvBinDir(venvPath), isWin2 ? "python.exe" : "python");
+}
+async function runPyprojectScript(workPath, scriptNames, env, useUserVirtualEnv = true) {
+  const pyprojectPath = (0, import_path3.join)(workPath, "pyproject.toml");
+  if (!import_fs2.default.existsSync(pyprojectPath))
+    return false;
+  let pyproject = null;
+  try {
+    pyproject = await (0, import_build_utils2.readConfigFile)(pyprojectPath);
+  } catch {
+    console.error("Failed to parse pyproject.toml");
+    return false;
+  }
+  const scripts = pyproject?.tool?.vercel?.scripts || {};
+  const candidates = typeof scriptNames === "string" ? [scriptNames] : Array.from(scriptNames);
+  const scriptToRun = candidates.find((name) => Boolean(scripts[name]));
+  if (!scriptToRun)
+    return false;
+  const systemPython = process.platform === "win32" ? "python" : "python3";
+  const finalEnv = { ...process.env, ...env };
+  if (useUserVirtualEnv) {
+    useVirtualEnv(workPath, finalEnv, systemPython);
+  }
+  const scriptCommand = scripts[scriptToRun];
+  if (typeof scriptCommand === "string" && scriptCommand.trim()) {
+    console.log(`Executing: ${scriptCommand}`);
+    await (0, import_build_utils2.execCommand)(scriptCommand, {
+      cwd: workPath,
+      env: finalEnv
+    });
+    return true;
+  }
+  return false;
+}
+function findDir({
+  file,
+  entryDirectory,
+  workPath,
+  fsFiles
+}) {
+  if (fsFiles[(0, import_path3.join)(entryDirectory, file)]) {
+    return (0, import_path3.join)(workPath, entryDirectory);
+  }
+  if (fsFiles[file]) {
+    return workPath;
+  }
+  return null;
+}
+
+// src/version.ts
+var import_build_utils3 = require("@vercel/build-utils");
+var DEFAULT_PYTHON_VERSION = "3.12";
+var allOptions = [
+  {
+    version: "3.14",
+    pipPath: "pip3.14",
+    pythonPath: "python3.14",
+    runtime: "python3.14"
+  },
+  {
+    version: "3.13",
+    pipPath: "pip3.13",
+    pythonPath: "python3.13",
+    runtime: "python3.13"
+  },
+  {
+    version: "3.12",
+    pipPath: "pip3.12",
+    pythonPath: "python3.12",
+    runtime: "python3.12"
+  },
+  {
+    version: "3.11",
+    pipPath: "pip3.11",
+    pythonPath: "python3.11",
+    runtime: "python3.11"
+  },
+  {
+    version: "3.10",
+    pipPath: "pip3.10",
+    pythonPath: "python3.10",
+    runtime: "python3.10"
+  },
+  {
+    version: "3.9",
+    pipPath: "pip3.9",
+    pythonPath: "python3.9",
+    runtime: "python3.9"
+  },
+  {
+    version: "3.6",
+    pipPath: "pip3.6",
+    pythonPath: "python3.6",
+    runtime: "python3.6",
+    discontinueDate: /* @__PURE__ */ new Date("2022-07-18")
+  }
+];
+function getDevPythonVersion() {
+  return {
+    version: "3",
+    pipPath: "pip3",
+    pythonPath: "python3",
+    runtime: "python3"
+  };
+}
+function getDefaultPythonVersion({
+  isDev
+}) {
+  if (isDev) {
+    return getDevPythonVersion();
+  }
+  const defaultOption = allOptions.find(
+    (opt) => opt.version === DEFAULT_PYTHON_VERSION && isInstalled(opt)
+  );
+  if (defaultOption) {
+    return defaultOption;
+  }
+  const selection = allOptions.find(isInstalled);
+  if (!selection) {
+    throw new import_build_utils3.NowBuildError({
+      code: "PYTHON_NOT_FOUND",
+      link: "https://vercel.link/python-version",
+      message: `Unable to find any supported Python versions.`
+    });
+  }
+  return selection;
+}
+function parseVersionTuple(input) {
+  const cleaned = input.trim().replace(/\s+/g, "");
+  const m = cleaned.match(/^(\d+)(?:\.(\d+))?/);
+  if (!m)
+    return null;
+  const major = Number(m[1]);
+  const minor = m[2] !== void 0 ? Number(m[2]) : 0;
+  if (Number.isNaN(major) || Number.isNaN(minor))
+    return null;
+  return [major, minor];
+}
+function compareTuples(a, b) {
+  if (a[0] !== b[0])
+    return a[0] - b[0];
+  return a[1] - b[1];
+}
+function parseSpecifier(spec) {
+  const s = spec.trim();
+  const m = s.match(
+    /^(<=|>=|==|!=|~=|<|>)\s*([0-9]+(?:\.[0-9]+)?)(?:\.[0-9]+)?(?:\.\*)?$/
+  ) || // Bare version like "3.11" or "3.11.4" -> implied ==
+  s.match(/^()([0-9]+(?:\.[0-9]+)?)(?:\.[0-9]+)?(?:\.\*)?$/);
+  if (!m)
+    return null;
+  const op = m[1] || "==";
+  const vt = parseVersionTuple(m[2]);
+  if (!vt)
+    return null;
+  return { op, ver: vt };
+}
+function satisfies(candidate, spec) {
+  const cmp = compareTuples(candidate, spec.ver);
+  switch (spec.op) {
+    case "==":
+      return cmp === 0;
+    case "!=":
+      return cmp !== 0;
+    case "<":
+      return cmp < 0;
+    case "<=":
+      return cmp <= 0;
+    case ">":
+      return cmp > 0;
+    case ">=":
+      return cmp >= 0;
+    case "~=": {
+      const lowerOk = cmp >= 0;
+      const upper = [spec.ver[0], spec.ver[1] + 1];
+      return lowerOk && compareTuples(candidate, upper) < 0;
+    }
+    default:
+      return false;
+  }
 }
-async function runPyprojectScript(workPath, scriptNames, env, useUserVirtualEnv = true) {
-  const pyprojectPath = (0, import_path.join)(workPath, "pyproject.toml");
-  if (!import_fs.default.existsSync(pyprojectPath))
-    return false;
-  let pyproject = null;
-  try {
-    pyproject = await (0, import_build_utils.readConfigFile)(pyprojectPath);
-  } catch {
-    console.error("Failed to parse pyproject.toml");
-    return false;
+function selectFromRequiresPython(expr) {
+  const raw = expr.trim();
+  if (!raw)
+    return void 0;
+  const parts = raw.split(",").map((p) => p.trim()).filter(Boolean);
+  const specifiers = [];
+  for (const p of parts) {
+    const sp = parseSpecifier(p);
+    if (sp)
+      specifiers.push(sp);
   }
-  const scripts = pyproject?.tool?.vercel?.scripts || {};
-  const candidates = typeof scriptNames === "string" ? [scriptNames] : Array.from(scriptNames);
-  const scriptToRun = candidates.find((name) => Boolean(scripts[name]));
-  if (!scriptToRun)
-    return false;
-  const systemPython = process.platform === "win32" ? "python" : "python3";
-  const finalEnv = { ...process.env, ...env };
-  if (useUserVirtualEnv) {
-    useVirtualEnv(workPath, finalEnv, systemPython);
+  if (specifiers.length === 0) {
+    return allOptions.find((o) => o.version === raw);
   }
-  const scriptCommand = scripts[scriptToRun];
-  if (typeof scriptCommand === "string" && scriptCommand.trim()) {
-    console.log(`Executing: ${scriptCommand}`);
-    await (0, import_build_utils.execCommand)(scriptCommand, {
-      cwd: workPath,
-      env: finalEnv
-    });
-    return true;
+  const matches = allOptions.filter((opt) => {
+    const vt = parseVersionTuple(opt.version);
+    return specifiers.every((sp) => satisfies(vt, sp));
+  });
+  if (matches.length === 0)
+    return void 0;
+  const defaultMatch = matches.find(
+    (opt) => opt.version === DEFAULT_PYTHON_VERSION && isInstalled(opt)
+  );
+  if (defaultMatch) {
+    return defaultMatch;
   }
-  return false;
+  const installedMatch = matches.find(isInstalled);
+  return installedMatch ?? matches[0];
 }
-async function runUvCommand(options) {
-  const { uvPath, args, cwd, venvPath } = options;
-  const pretty = `uv ${args.join(" ")}`;
-  (0, import_build_utils.debug)(`Running "${pretty}"...`);
-  if (!uvPath) {
-    throw new Error(`uv is required to run "${pretty}" but is not available`);
+function getSupportedPythonVersion({
+  isDev,
+  declaredPythonVersion
+}) {
+  if (isDev) {
+    return getDevPythonVersion();
   }
-  try {
-    await (0, import_execa.default)(uvPath, args, {
-      cwd,
-      env: createVenvEnv(venvPath)
-    });
-    return true;
-  } catch (err) {
-    const error = new Error(
-      `Failed to run "${pretty}": ${err instanceof Error ? err.message : String(err)}`
-    );
-    if (err && typeof err === "object") {
-      if ("code" in err) {
-        error.code = err.code;
-      } else if ("signal" in err) {
-        error.code = err.signal;
+  let selection = getDefaultPythonVersion({ isDev: false });
+  if (declaredPythonVersion) {
+    const { version: version2, source } = declaredPythonVersion;
+    let requested;
+    if (source === "pyproject.toml" || source === ".python-version") {
+      requested = selectFromRequiresPython(version2);
+    } else {
+      requested = allOptions.find((o) => o.version === version2);
+    }
+    if (requested) {
+      if (isDiscontinued(requested)) {
+        throw new import_build_utils3.NowBuildError({
+          code: "BUILD_UTILS_PYTHON_VERSION_DISCONTINUED",
+          link: "https://vercel.link/python-version",
+          message: `Python version "${requested.version}" detected in ${source} is discontinued and must be upgraded.`
+        });
+      }
+      if (isInstalled(requested)) {
+        selection = requested;
+        console.log(`Using Python ${selection.version} from ${source}`);
+      } else {
+        console.warn(
+          `Warning: Python version "${version2}" detected in ${source} is not installed and will be ignored. https://vercel.link/python-version`
+        );
+        console.log(`Using python version: ${selection.version}`);
       }
+    } else {
+      console.warn(
+        `Warning: Python version "${version2}" detected in ${source} is invalid and will be ignored. https://vercel.link/python-version`
+      );
+      console.log(`Using python version: ${selection.version}`);
     }
-    throw error;
+  } else {
+    console.log(
+      `No Python version specified in .python-version, pyproject.toml, or Pipfile.lock. Using python version: ${selection.version}`
+    );
   }
+  if (isDiscontinued(selection)) {
+    throw new import_build_utils3.NowBuildError({
+      code: "BUILD_UTILS_PYTHON_VERSION_DISCONTINUED",
+      link: "https://vercel.link/python-version",
+      message: `Python version "${selection.version}" declared in project configuration is discontinued and must be upgraded.`
+    });
+  }
+  if (selection.discontinueDate) {
+    const d = selection.discontinueDate.toISOString().split("T")[0];
+    const srcSuffix = declaredPythonVersion ? `detected in ${declaredPythonVersion.source}` : "selected by runtime";
+    console.warn(
+      `Error: Python version "${selection.version}" ${srcSuffix} has reached End-of-Life. Deployments created on or after ${d} will fail to build. https://vercel.link/python-version`
+    );
+  }
+  return selection;
 }
-function findDir({
-  file,
-  entryDirectory,
-  workPath,
-  fsFiles
-}) {
-  if (fsFiles[(0, import_path.join)(entryDirectory, file)]) {
-    return (0, import_path.join)(workPath, entryDirectory);
+function isDiscontinued({ discontinueDate }) {
+  const today = Date.now();
+  return discontinueDate !== void 0 && discontinueDate.getTime() <= today;
+}
+var installedPythonsCache = null;
+function getInstalledPythons() {
+  if (installedPythonsCache !== null) {
+    return installedPythonsCache;
   }
-  if (fsFiles[file]) {
-    return workPath;
+  const uvPath = findUvInPath();
+  if (!uvPath) {
+    throw new import_build_utils3.NowBuildError({
+      code: "UV_ERROR",
+      link: "https://vercel.link/python-version",
+      message: "uv is required but was not found in PATH."
+    });
+  }
+  const uv = new UvRunner(uvPath);
+  installedPythonsCache = uv.listInstalledPythons();
+  return installedPythonsCache;
+}
+function isInstalled({ version: version2 }) {
+  try {
+    const installed = getInstalledPythons();
+    return installed.has(version2);
+  } catch (err) {
+    throw new import_build_utils3.NowBuildError({
+      code: "UV_ERROR",
+      link: "https://vercel.link/python-version",
+      message: err instanceof Error ? err.message : String(err)
+    });
   }
-  return null;
 }
 
 // src/install.ts
-var isWin2 = process.platform === "win32";
-var uvExec = isWin2 ? "uv.exe" : "uv";
+var isWin3 = process.platform === "win32";
 var makeDependencyCheckCode = (dependency) => `
 from importlib import util
 dep = '${dependency}'.replace('-', '_')
 spec = util.find_spec(dep)
 print(spec.origin)
 `;
-async function isInstalled(pythonPath, dependency, cwd) {
+async function isInstalled2(pythonPath, dependency, cwd) {
   try {
-    const { stdout } = await (0, import_execa2.default)(
+    const { stdout } = await (0, import_execa3.default)(
       pythonPath,
       ["-c", makeDependencyCheckCode(dependency)],
       {
         stdio: "pipe",
         cwd,
-        env: { ...process.env, PYTHONPATH: (0, import_path2.join)(cwd, resolveVendorDir()) }
+        env: { ...process.env, PYTHONPATH: (0, import_path4.join)(cwd, resolveVendorDir()) }
       }
     );
     return stdout.startsWith(cwd);
@@ -2932,13 +3383,13 @@ pkg_resources.require(dependencies)
 `;
 async function areRequirementsInstalled(pythonPath, requirementsPath, cwd) {
   try {
-    await (0, import_execa2.default)(
+    await (0, import_execa3.default)(
       pythonPath,
       ["-c", makeRequirementsCheckCode(requirementsPath)],
       {
         stdio: "pipe",
         cwd,
-        env: { ...process.env, PYTHONPATH: (0, import_path2.join)(cwd, resolveVendorDir()) }
+        env: { ...process.env, PYTHONPATH: (0, import_path4.join)(cwd, resolveVendorDir()) }
       }
     );
     return true;
@@ -2946,24 +3397,6 @@ async function areRequirementsInstalled(pythonPath, requirementsPath, cwd) {
     return false;
   }
 }
-async function runUvSync({
-  uvPath,
-  venvPath,
-  projectDir,
-  locked
-}) {
-  const args = ["sync", "--active", "--no-dev", "--link-mode", "copy"];
-  if (locked) {
-    args.push("--locked");
-  }
-  args.push("--no-editable");
-  await runUvCommand({
-    uvPath,
-    args,
-    cwd: projectDir,
-    venvPath
-  });
-}
 async function getSitePackagesDirs(pythonBin) {
   const code = `
 import json
@@ -2975,14 +3408,14 @@ for key in ("purelib", "platlib"):
         paths.append(candidate)
 print(json.dumps(paths))
 `.trim();
-  const { stdout } = await (0, import_execa2.default)(pythonBin, ["-c", code]);
+  const { stdout } = await (0, import_execa3.default)(pythonBin, ["-c", code]);
   try {
     const parsed = JSON.parse(stdout);
     if (Array.isArray(parsed)) {
       return parsed.filter((p) => typeof p === "string");
     }
   } catch (err) {
-    (0, import_build_utils2.debug)("Failed to parse site-packages output", err);
+    (0, import_build_utils4.debug)("Failed to parse site-packages output", err);
   }
   return [];
 }
@@ -3033,26 +3466,26 @@ async function detectInstallSource({
   let manifestType = null;
   if (uvLockDir && pyprojectDir) {
     manifestType = "uv.lock";
-    manifestPath = (0, import_path2.join)(uvLockDir, "uv.lock");
+    manifestPath = (0, import_path4.join)(uvLockDir, "uv.lock");
   } else if (pyprojectDir) {
     manifestType = "pyproject.toml";
-    manifestPath = (0, import_path2.join)(pyprojectDir, "pyproject.toml");
+    manifestPath = (0, import_path4.join)(pyprojectDir, "pyproject.toml");
   } else if (pipfileLockDir) {
     manifestType = "Pipfile.lock";
-    manifestPath = (0, import_path2.join)(pipfileLockDir, "Pipfile.lock");
+    manifestPath = (0, import_path4.join)(pipfileLockDir, "Pipfile.lock");
   } else if (pipfileDir) {
     manifestType = "Pipfile";
-    manifestPath = (0, import_path2.join)(pipfileDir, "Pipfile");
+    manifestPath = (0, import_path4.join)(pipfileDir, "Pipfile");
   } else if (requirementsDir) {
     manifestType = "requirements.txt";
-    manifestPath = (0, import_path2.join)(requirementsDir, "requirements.txt");
+    manifestPath = (0, import_path4.join)(requirementsDir, "requirements.txt");
   }
   let manifestContent;
   if (manifestPath) {
     try {
-      manifestContent = await import_fs2.default.promises.readFile(manifestPath, "utf8");
+      manifestContent = await import_fs3.default.promises.readFile(manifestPath, "utf8");
     } catch (err) {
-      (0, import_build_utils2.debug)("Failed to read install manifest contents", err);
+      (0, import_build_utils4.debug)("Failed to read install manifest contents", err);
     }
   }
   return { manifestPath, manifestType, manifestContent };
@@ -3062,7 +3495,7 @@ async function createPyprojectToml({
   pyprojectPath,
   dependencies
 }) {
-  const requiresPython = ">=3.12";
+  const requiresPython = `~=${DEFAULT_PYTHON_VERSION}`;
   const depsToml = dependencies.length > 0 ? [
     "dependencies = [",
     ...dependencies.map((dep) => `  "${dep}",`),
@@ -3079,47 +3512,7 @@ async function createPyprojectToml({
     depsToml,
     ""
   ].join("\n");
-  await import_fs2.default.promises.writeFile(pyprojectPath, content);
-}
-async function uvLock({
-  projectDir,
-  uvPath
-}) {
-  const args = ["lock"];
-  const pretty = `${uvPath} ${args.join(" ")}`;
-  (0, import_build_utils2.debug)(`Running "${pretty}" in ${projectDir}...`);
-  try {
-    await (0, import_execa2.default)(uvPath, args, { cwd: projectDir, env: getProtectedUvEnv() });
-  } catch (err) {
-    throw new Error(
-      `Failed to run "${pretty}": ${err instanceof Error ? err.message : String(err)}`
-    );
-  }
-}
-async function uvAddDependencies({
-  projectDir,
-  uvPath,
-  venvPath,
-  dependencies
-}) {
-  const toAdd = dependencies.filter(Boolean);
-  if (!toAdd.length)
-    return;
-  const args = ["add", "--active", ...toAdd];
-  const pretty = `${uvPath} ${args.join(" ")}`;
-  (0, import_build_utils2.debug)(`Running "${pretty}" in ${projectDir}...`);
-  await runUvCommand({ uvPath, args, cwd: projectDir, venvPath });
-}
-async function uvAddFromFile({
-  projectDir,
-  uvPath,
-  venvPath,
-  requirementsPath
-}) {
-  const args = ["add", "--active", "-r", requirementsPath];
-  const pretty = `${uvPath} ${args.join(" ")}`;
-  (0, import_build_utils2.debug)(`Running "${pretty}" in ${projectDir}...`);
-  await runUvCommand({ uvPath, args, cwd: projectDir, venvPath });
+  await import_fs3.default.promises.writeFile(pyprojectPath, content);
 }
 function getDependencyName(spec) {
   const match = spec.match(/^[A-Za-z0-9_.-]+/);
@@ -3131,10 +3524,10 @@ async function filterMissingRuntimeDependencies({
 }) {
   let declared = [];
   try {
-    const config = await (0, import_build_utils2.readConfigFile)(pyprojectPath);
+    const config = await (0, import_build_utils4.readConfigFile)(pyprojectPath);
     declared = config?.project?.dependencies || [];
   } catch (err) {
-    (0, import_build_utils2.debug)("Failed to parse pyproject.toml when filtering runtime deps", err);
+    (0, import_build_utils4.debug)("Failed to parse pyproject.toml when filtering runtime deps", err);
   }
   const declaredNames = new Set(declared.map(getDependencyName));
   return runtimeDependencies.filter((spec) => {
@@ -3143,12 +3536,12 @@ async function filterMissingRuntimeDependencies({
   });
 }
 function findUvLockUpwards(startDir, repoRootPath) {
-  const start = (0, import_path2.resolve)(startDir);
-  const base = repoRootPath ? (0, import_path2.resolve)(repoRootPath) : void 0;
-  for (const dir of (0, import_build_utils2.traverseUpDirectories)({ start, base })) {
-    const lockPath = (0, import_path2.join)(dir, "uv.lock");
-    const pyprojectPath = (0, import_path2.join)(dir, "pyproject.toml");
-    if (import_fs2.default.existsSync(lockPath) && import_fs2.default.existsSync(pyprojectPath)) {
+  const start = (0, import_path4.resolve)(startDir);
+  const base = repoRootPath ? (0, import_path4.resolve)(repoRootPath) : void 0;
+  for (const dir of (0, import_build_utils4.traverseUpDirectories)({ start, base })) {
+    const lockPath = (0, import_path4.join)(dir, "uv.lock");
+    const pyprojectPath = (0, import_path4.join)(dir, "pyproject.toml");
+    if (import_fs3.default.existsSync(lockPath) && import_fs3.default.existsSync(pyprojectPath)) {
       return lockPath;
     }
   }
@@ -3161,11 +3554,12 @@ async function ensureUvProject({
   repoRootPath,
   pythonPath,
   pipPath,
-  uvPath,
+  uv,
   venvPath,
   meta,
   runtimeDependencies
 }) {
+  const uvPath = uv.getPath();
   const installInfo = await detectInstallSource({
     workPath,
     entryDirectory,
@@ -3179,9 +3573,9 @@ async function ensureUvProject({
     if (!manifestPath) {
       throw new Error("Expected uv.lock path to be resolved, but it was null");
     }
-    projectDir = (0, import_path2.dirname)(manifestPath);
-    pyprojectPath = (0, import_path2.join)(projectDir, "pyproject.toml");
-    if (!import_fs2.default.existsSync(pyprojectPath)) {
+    projectDir = (0, import_path4.dirname)(manifestPath);
+    pyprojectPath = (0, import_path4.join)(projectDir, "pyproject.toml");
+    if (!import_fs3.default.existsSync(pyprojectPath)) {
       throw new Error(
         `Expected "pyproject.toml" next to "uv.lock" in "${projectDir}"`
       );
@@ -3194,14 +3588,14 @@ async function ensureUvProject({
         "Expected pyproject.toml path to be resolved, but it was null"
       );
     }
-    projectDir = (0, import_path2.dirname)(manifestPath);
+    projectDir = (0, import_path4.dirname)(manifestPath);
     pyprojectPath = manifestPath;
     console.log("Installing required dependencies from pyproject.toml...");
     const workspaceLock = findUvLockUpwards(projectDir, repoRootPath);
     if (workspaceLock) {
       lockPath = workspaceLock;
     } else {
-      await uvLock({ projectDir, uvPath });
+      await uv.lock(projectDir);
     }
   } else if (manifestType === "Pipfile.lock" || manifestType === "Pipfile") {
     if (!manifestPath) {
@@ -3209,7 +3603,7 @@ async function ensureUvProject({
         "Expected Pipfile/Pipfile.lock path to be resolved, but it was null"
       );
     }
-    projectDir = (0, import_path2.dirname)(manifestPath);
+    projectDir = (0, import_path4.dirname)(manifestPath);
     console.log(`Installing required dependencies from ${manifestType}...`);
     const exportedReq = await exportRequirementsFromPipfile({
       pythonPath,
@@ -3218,18 +3612,17 @@ async function ensureUvProject({
       projectDir,
       meta
     });
-    pyprojectPath = (0, import_path2.join)(projectDir, "pyproject.toml");
-    if (!import_fs2.default.existsSync(pyprojectPath)) {
+    pyprojectPath = (0, import_path4.join)(projectDir, "pyproject.toml");
+    if (!import_fs3.default.existsSync(pyprojectPath)) {
       await createPyprojectToml({
         projectName: "app",
         pyprojectPath,
         dependencies: []
       });
     }
-    await uvAddFromFile({
-      projectDir,
-      uvPath,
+    await uv.addFromFile({
       venvPath,
+      projectDir,
       requirementsPath: exportedReq
     });
   } else if (manifestType === "requirements.txt") {
@@ -3238,27 +3631,26 @@ async function ensureUvProject({
         "Expected requirements.txt path to be resolved, but it was null"
       );
     }
-    projectDir = (0, import_path2.dirname)(manifestPath);
-    pyprojectPath = (0, import_path2.join)(projectDir, "pyproject.toml");
+    projectDir = (0, import_path4.dirname)(manifestPath);
+    pyprojectPath = (0, import_path4.join)(projectDir, "pyproject.toml");
     console.log(
       "Installing required dependencies from requirements.txt with uv..."
     );
-    if (!import_fs2.default.existsSync(pyprojectPath)) {
+    if (!import_fs3.default.existsSync(pyprojectPath)) {
       await createPyprojectToml({
         projectName: "app",
         pyprojectPath,
         dependencies: []
       });
     }
-    await uvAddFromFile({
-      projectDir,
-      uvPath,
+    await uv.addFromFile({
       venvPath,
+      projectDir,
       requirementsPath: manifestPath
     });
   } else {
     projectDir = workPath;
-    pyprojectPath = (0, import_path2.join)(projectDir, "pyproject.toml");
+    pyprojectPath = (0, import_path4.join)(projectDir, "pyproject.toml");
     console.log(
       "No Python manifest found; creating an empty pyproject.toml and uv.lock..."
     );
@@ -3267,7 +3659,7 @@ async function ensureUvProject({
       pyprojectPath,
       dependencies: []
     });
-    await uvLock({ projectDir, uvPath });
+    await uv.lock(projectDir);
   }
   if (runtimeDependencies.length) {
     const missingRuntimeDeps = await filterMissingRuntimeDependencies({
@@ -3275,44 +3667,18 @@ async function ensureUvProject({
       runtimeDependencies
     });
     if (missingRuntimeDeps.length) {
-      await uvAddDependencies({
-        projectDir,
-        uvPath,
+      await uv.addDependencies({
         venvPath,
+        projectDir,
         dependencies: missingRuntimeDeps
       });
     }
   }
-  const resolvedLockPath = lockPath && import_fs2.default.existsSync(lockPath) ? lockPath : findUvLockUpwards(projectDir, repoRootPath) || (0, import_path2.join)(projectDir, "uv.lock");
+  const resolvedLockPath = lockPath && import_fs3.default.existsSync(lockPath) ? lockPath : findUvLockUpwards(projectDir, repoRootPath) || (0, import_path4.join)(projectDir, "uv.lock");
   return { projectDir, pyprojectPath, lockPath: resolvedLockPath };
 }
-async function getGlobalScriptsDir(pythonPath) {
-  const code = `import sysconfig; print(sysconfig.get_path('scripts'))`;
-  try {
-    const { stdout } = await (0, import_execa2.default)(pythonPath, ["-c", code]);
-    const out = stdout.trim();
-    return out || null;
-  } catch (err) {
-    (0, import_build_utils2.debug)("Failed to resolve Python global scripts directory", err);
-    return null;
-  }
-}
-async function getUserScriptsDir(pythonPath) {
-  const code = `import sys, sysconfig; print(sysconfig.get_path('scripts', scheme=('nt_user' if sys.platform == 'win32' else 'posix_user')))`.replace(
-    /\n/g,
-    " "
-  );
-  try {
-    const { stdout } = await (0, import_execa2.default)(pythonPath, ["-c", code]);
-    const out = stdout.trim();
-    return out || null;
-  } catch (err) {
-    (0, import_build_utils2.debug)("Failed to resolve Python user scripts directory", err);
-    return null;
-  }
-}
 async function pipInstall(pipPath, uvPath, workPath, args, targetDir) {
-  const target = targetDir ? (0, import_path2.join)(targetDir, resolveVendorDir()) : resolveVendorDir();
+  const target = targetDir ? (0, import_path4.join)(targetDir, resolveVendorDir()) : resolveVendorDir();
   process.env.PIP_USER = "0";
   if (uvPath) {
     const uvArgs = [
@@ -3325,111 +3691,38 @@ async function pipInstall(pipPath, uvPath, workPath, args, targetDir) {
       ...filterUnsafeUvPipArgs(args)
     ];
     const prettyUv = `${uvPath} ${uvArgs.join(" ")}`;
-    (0, import_build_utils2.debug)(`Running "${prettyUv}"...`);
+    (0, import_build_utils4.debug)(`Running "${prettyUv}"...`);
     try {
-      await (0, import_execa2.default)(uvPath, uvArgs, {
+      await (0, import_execa3.default)(uvPath, uvArgs, {
         cwd: workPath,
         env: getProtectedUvEnv()
       });
       return;
     } catch (err) {
       console.log(`Failed to run "${prettyUv}", falling back to pip`);
-      (0, import_build_utils2.debug)(`error: ${err}`);
+      (0, import_build_utils4.debug)(`error: ${err}`);
     }
   }
   const cmdArgs = [
     "install",
     "--disable-pip-version-check",
     "--no-compile",
-    "--no-cache-dir",
-    "--target",
-    target,
-    ...args
-  ];
-  const pretty = `${pipPath} ${cmdArgs.join(" ")}`;
-  (0, import_build_utils2.debug)(`Running "${pretty}"...`);
-  try {
-    await (0, import_execa2.default)(pipPath, cmdArgs, {
-      cwd: workPath
-    });
-  } catch (err) {
-    console.log(`Failed to run "${pretty}"`);
-    (0, import_build_utils2.debug)(`error: ${err}`);
-    throw err;
-  }
-}
-async function maybeFindUvBin(pythonPath) {
-  const found = import_which.default.sync("uv", { nothrow: true });
-  if (found)
-    return found;
-  try {
-    const globalScriptsDir = await getGlobalScriptsDir(pythonPath);
-    if (globalScriptsDir) {
-      const uvPath = (0, import_path2.join)(globalScriptsDir, uvExec);
-      if (import_fs2.default.existsSync(uvPath))
-        return uvPath;
-    }
-  } catch (err) {
-    (0, import_build_utils2.debug)("Failed to resolve Python global scripts directory", err);
-  }
-  try {
-    const userScriptsDir = await getUserScriptsDir(pythonPath);
-    if (userScriptsDir) {
-      const uvPath = (0, import_path2.join)(userScriptsDir, uvExec);
-      if (import_fs2.default.existsSync(uvPath))
-        return uvPath;
-    }
-  } catch (err) {
-    (0, import_build_utils2.debug)("Failed to resolve Python user scripts directory", err);
-  }
-  try {
-    const candidates = [];
-    if (!isWin2) {
-      candidates.push((0, import_path2.join)(import_os.default.homedir(), ".local", "bin", "uv"));
-      candidates.push("/usr/local/bin/uv");
-      candidates.push("/opt/homebrew/bin/uv");
-    } else {
-      candidates.push("C:\\Users\\Public\\uv\\uv.exe");
-    }
-    for (const p of candidates) {
-      if (import_fs2.default.existsSync(p))
-        return p;
-    }
-  } catch (err) {
-    (0, import_build_utils2.debug)("Failed to resolve uv fallback paths", err);
-  }
-  return null;
-}
-async function getUvBinaryOrInstall(pythonPath) {
-  const uvBin = await maybeFindUvBin(pythonPath);
-  if (uvBin)
-    return uvBin;
-  try {
-    console.log("Installing uv...");
-    await (0, import_execa2.default)(
-      pythonPath,
-      [
-        "-m",
-        "pip",
-        "install",
-        "--disable-pip-version-check",
-        "--no-cache-dir",
-        "--user",
-        "uv==0.8.18"
-      ],
-      { env: { ...process.env, PIP_USER: "1" } }
-    );
+    "--no-cache-dir",
+    "--target",
+    target,
+    ...args
+  ];
+  const pretty = `${pipPath} ${cmdArgs.join(" ")}`;
+  (0, import_build_utils4.debug)(`Running "${pretty}"...`);
+  try {
+    await (0, import_execa3.default)(pipPath, cmdArgs, {
+      cwd: workPath
+    });
   } catch (err) {
-    throw new Error(
-      `Failed to install uv via pip: ${err instanceof Error ? err.message : String(err)}`
-    );
-  }
-  const resolvedUvBin = await maybeFindUvBin(pythonPath);
-  if (!resolvedUvBin) {
-    throw new Error("Unable to resolve uv binary after pip install");
+    console.log(`Failed to run "${pretty}"`);
+    (0, import_build_utils4.debug)(`error: ${err}`);
+    throw err;
   }
-  console.log(`Installed uv at "${resolvedUvBin}"`);
-  return resolvedUvBin;
 }
 async function installRequirement({
   pythonPath,
@@ -3443,8 +3736,8 @@ async function installRequirement({
   args = []
 }) {
   const actualTargetDir = targetDir || workPath;
-  if (meta.isDev && await isInstalled(pythonPath, dependency, actualTargetDir)) {
-    (0, import_build_utils2.debug)(
+  if (meta.isDev && await isInstalled2(pythonPath, dependency, actualTargetDir)) {
+    (0, import_build_utils4.debug)(
       `Skipping ${dependency} dependency installation, already installed in ${actualTargetDir}`
     );
     return;
@@ -3464,7 +3757,7 @@ async function installRequirementsFile({
 }) {
   const actualTargetDir = targetDir || workPath;
   if (meta.isDev && await areRequirementsInstalled(pythonPath, filePath, actualTargetDir)) {
-    (0, import_build_utils2.debug)(`Skipping requirements file installation, already installed`);
+    (0, import_build_utils4.debug)(`Skipping requirements file installation, already installed`);
     return;
   }
   await pipInstall(
@@ -3475,9 +3768,6 @@ async function installRequirementsFile({
     targetDir
   );
 }
-function filterUnsafeUvPipArgs(args) {
-  return args.filter((arg) => arg !== "--no-warn-script-location");
-}
 async function exportRequirementsFromPipfile({
   pythonPath,
   pipPath,
@@ -3485,8 +3775,8 @@ async function exportRequirementsFromPipfile({
   projectDir,
   meta
 }) {
-  const tempDir = await import_fs2.default.promises.mkdtemp(
-    (0, import_path2.join)(import_os.default.tmpdir(), "vercel-pipenv-")
+  const tempDir = await import_fs3.default.promises.mkdtemp(
+    (0, import_path4.join)(import_os2.default.tmpdir(), "vercel-pipenv-")
   );
   await installRequirement({
     pythonPath,
@@ -3498,12 +3788,12 @@ async function exportRequirementsFromPipfile({
     args: ["--no-warn-script-location"],
     uvPath
   });
-  const tempVendorDir = (0, import_path2.join)(tempDir, resolveVendorDir());
-  const convertCmd = isWin2 ? (0, import_path2.join)(tempVendorDir, "Scripts", "pipfile2req.exe") : (0, import_path2.join)(tempVendorDir, "bin", "pipfile2req");
-  (0, import_build_utils2.debug)(`Running "${convertCmd}" in ${projectDir}...`);
+  const tempVendorDir = (0, import_path4.join)(tempDir, resolveVendorDir());
+  const convertCmd = isWin3 ? (0, import_path4.join)(tempVendorDir, "Scripts", "pipfile2req.exe") : (0, import_path4.join)(tempVendorDir, "bin", "pipfile2req");
+  (0, import_build_utils4.debug)(`Running "${convertCmd}" in ${projectDir}...`);
   let stdout;
   try {
-    const { stdout: out } = await (0, import_execa2.default)(convertCmd, [], {
+    const { stdout: out } = await (0, import_execa3.default)(convertCmd, [], {
       cwd: projectDir,
       env: { ...process.env, PYTHONPATH: tempVendorDir }
     });
@@ -3513,9 +3803,9 @@ async function exportRequirementsFromPipfile({
       `Failed to run "${convertCmd}": ${err instanceof Error ? err.message : String(err)}`
     );
   }
-  const outPath = (0, import_path2.join)(tempDir, "requirements.pipenv.txt");
-  await import_fs2.default.promises.writeFile(outPath, stdout);
-  (0, import_build_utils2.debug)(`Exported pipfile requirements to ${outPath}`);
+  const outPath = (0, import_path4.join)(tempDir, "requirements.pipenv.txt");
+  await import_fs3.default.promises.writeFile(outPath, stdout);
+  (0, import_build_utils4.debug)(`Exported pipfile requirements to ${outPath}`);
   return outPath;
 }
 async function mirrorSitePackagesIntoVendor({
@@ -3526,19 +3816,19 @@ async function mirrorSitePackagesIntoVendor({
   try {
     const sitePackageDirs = await getVenvSitePackagesDirs(venvPath);
     for (const dir of sitePackageDirs) {
-      if (!import_fs2.default.existsSync(dir))
+      if (!import_fs3.default.existsSync(dir))
         continue;
-      const dirFiles = await (0, import_build_utils2.glob)("**", dir);
+      const dirFiles = await (0, import_build_utils4.glob)("**", dir);
       for (const relativePath of Object.keys(dirFiles)) {
         if (relativePath.endsWith(".pyc") || relativePath.includes("__pycache__")) {
           continue;
         }
-        const srcFsPath = (0, import_path2.join)(dir, relativePath);
-        const bundlePath = (0, import_path2.join)(vendorDirName, relativePath).replace(
+        const srcFsPath = (0, import_path4.join)(dir, relativePath);
+        const bundlePath = (0, import_path4.join)(vendorDirName, relativePath).replace(
           /\\/g,
           "/"
         );
-        vendorFiles[bundlePath] = new import_build_utils2.FileFsRef({ fsPath: srcFsPath });
+        vendorFiles[bundlePath] = new import_build_utils4.FileFsRef({ fsPath: srcFsPath });
       }
     }
   } catch (err) {
@@ -3549,244 +3839,18 @@ async function mirrorSitePackagesIntoVendor({
 }
 
 // src/index.ts
-var import_build_utils8 = require("@vercel/build-utils");
-
-// src/version.ts
-var import_build_utils3 = require("@vercel/build-utils");
-var import_which2 = __toESM(require_lib());
-var DEFAULT_PYTHON_VERSION = "3.12";
-var allOptions = [
-  {
-    version: "3.14",
-    pipPath: "pip3.14",
-    pythonPath: "python3.14",
-    runtime: "python3.14"
-  },
-  {
-    version: "3.13",
-    pipPath: "pip3.13",
-    pythonPath: "python3.13",
-    runtime: "python3.13"
-  },
-  {
-    version: "3.12",
-    pipPath: "pip3.12",
-    pythonPath: "python3.12",
-    runtime: "python3.12"
-  },
-  {
-    version: "3.11",
-    pipPath: "pip3.11",
-    pythonPath: "python3.11",
-    runtime: "python3.11"
-  },
-  {
-    version: "3.10",
-    pipPath: "pip3.10",
-    pythonPath: "python3.10",
-    runtime: "python3.10"
-  },
-  {
-    version: "3.9",
-    pipPath: "pip3.9",
-    pythonPath: "python3.9",
-    runtime: "python3.9"
-  },
-  {
-    version: "3.6",
-    pipPath: "pip3.6",
-    pythonPath: "python3.6",
-    runtime: "python3.6",
-    discontinueDate: /* @__PURE__ */ new Date("2022-07-18")
-  }
-];
-function getDevPythonVersion() {
-  return {
-    version: "3",
-    pipPath: "pip3",
-    pythonPath: "python3",
-    runtime: "python3"
-  };
-}
-function getLatestPythonVersion({
-  isDev
-}) {
-  if (isDev) {
-    return getDevPythonVersion();
-  }
-  const defaultOption = allOptions.find(
-    (opt) => opt.version === DEFAULT_PYTHON_VERSION
-  );
-  if (defaultOption && isInstalled2(defaultOption)) {
-    return defaultOption;
-  }
-  const selection = allOptions.find(isInstalled2);
-  if (!selection) {
-    throw new import_build_utils3.NowBuildError({
-      code: "PYTHON_NOT_FOUND",
-      link: "https://vercel.link/python-version",
-      message: `Unable to find any supported Python versions.`
-    });
-  }
-  return selection;
-}
-function parseVersionTuple(input) {
-  const cleaned = input.trim().replace(/\s+/g, "");
-  const m = cleaned.match(/^(\d+)(?:\.(\d+))?/);
-  if (!m)
-    return null;
-  const major = Number(m[1]);
-  const minor = m[2] !== void 0 ? Number(m[2]) : 0;
-  if (Number.isNaN(major) || Number.isNaN(minor))
-    return null;
-  return [major, minor];
-}
-function compareTuples(a, b) {
-  if (a[0] !== b[0])
-    return a[0] - b[0];
-  return a[1] - b[1];
-}
-function parseSpecifier(spec) {
-  const s = spec.trim();
-  const m = s.match(/^(<=|>=|==|!=|~=|<|>)\s*([0-9]+(?:\.[0-9]+)?)(?:\.\*)?$/) || // Bare version like "3.11" -> implied ==
-  s.match(/^()([0-9]+(?:\.[0-9]+)?)(?:\.\*)?$/);
-  if (!m)
-    return null;
-  const op = m[1] || "==";
-  const vt = parseVersionTuple(m[2]);
-  if (!vt)
-    return null;
-  return { op, ver: vt };
-}
-function satisfies(candidate, spec) {
-  const cmp = compareTuples(candidate, spec.ver);
-  switch (spec.op) {
-    case "==":
-      return cmp === 0;
-    case "!=":
-      return cmp !== 0;
-    case "<":
-      return cmp < 0;
-    case "<=":
-      return cmp <= 0;
-    case ">":
-      return cmp > 0;
-    case ">=":
-      return cmp >= 0;
-    case "~=": {
-      const lowerOk = cmp >= 0;
-      const upper = [spec.ver[0], spec.ver[1] + 1];
-      return lowerOk && compareTuples(candidate, upper) < 0;
-    }
-    default:
-      return false;
-  }
-}
-function selectFromRequiresPython(expr) {
-  const raw = expr.trim();
-  if (!raw)
-    return void 0;
-  const parts = raw.split(",").map((p) => p.trim()).filter(Boolean);
-  const specifiers = [];
-  for (const p of parts) {
-    const sp = parseSpecifier(p);
-    if (sp)
-      specifiers.push(sp);
-  }
-  if (specifiers.length === 0) {
-    return allOptions.find((o) => o.version === raw);
-  }
-  const matches = allOptions.filter((opt) => {
-    const vt = parseVersionTuple(opt.version);
-    return specifiers.every((sp) => satisfies(vt, sp));
-  });
-  if (matches.length === 0)
-    return void 0;
-  const installedMatch = matches.find(isInstalled2);
-  return installedMatch ?? matches[0];
-}
-function getSupportedPythonVersion({
-  isDev,
-  declaredPythonVersion
-}) {
-  if (isDev) {
-    return getDevPythonVersion();
-  }
-  let selection = getLatestPythonVersion({ isDev: false });
-  if (declaredPythonVersion) {
-    const { version: version2, source } = declaredPythonVersion;
-    let requested;
-    if (source === "pyproject.toml") {
-      requested = selectFromRequiresPython(version2);
-    } else {
-      requested = allOptions.find((o) => o.version === version2);
-    }
-    if (requested) {
-      if (isDiscontinued(requested)) {
-        throw new import_build_utils3.NowBuildError({
-          code: "BUILD_UTILS_PYTHON_VERSION_DISCONTINUED",
-          link: "https://vercel.link/python-version",
-          message: `Python version "${requested.version}" detected in ${source} is discontinued and must be upgraded.`
-        });
-      }
-      if (isInstalled2(requested)) {
-        selection = requested;
-        console.log(`Using Python ${selection.version} from ${source}`);
-      } else {
-        console.warn(
-          `Warning: Python version "${version2}" detected in ${source} is not installed and will be ignored. https://vercel.link/python-version`
-        );
-        console.log(
-          `Falling back to latest installed version: ${selection.version}`
-        );
-      }
-    } else {
-      console.warn(
-        `Warning: Python version "${version2}" detected in ${source} is invalid and will be ignored. https://vercel.link/python-version`
-      );
-      console.log(
-        `Falling back to latest installed version: ${selection.version}`
-      );
-    }
-  } else {
-    console.log(
-      `No Python version specified in pyproject.toml or Pipfile.lock. Using latest installed version: ${selection.version}`
-    );
-  }
-  if (isDiscontinued(selection)) {
-    throw new import_build_utils3.NowBuildError({
-      code: "BUILD_UTILS_PYTHON_VERSION_DISCONTINUED",
-      link: "https://vercel.link/python-version",
-      message: `Python version "${selection.version}" declared in project configuration is discontinued and must be upgraded.`
-    });
-  }
-  if (selection.discontinueDate) {
-    const d = selection.discontinueDate.toISOString().split("T")[0];
-    const srcSuffix = declaredPythonVersion ? `detected in ${declaredPythonVersion.source}` : "selected by runtime";
-    console.warn(
-      `Error: Python version "${selection.version}" ${srcSuffix} has reached End-of-Life. Deployments created on or after ${d} will fail to build. https://vercel.link/python-version`
-    );
-  }
-  return selection;
-}
-function isDiscontinued({ discontinueDate }) {
-  const today = Date.now();
-  return discontinueDate !== void 0 && discontinueDate.getTime() <= today;
-}
-function isInstalled2({ pipPath, pythonPath }) {
-  return Boolean(import_which2.default.sync(pipPath, { nothrow: true })) && Boolean(import_which2.default.sync(pythonPath, { nothrow: true }));
-}
+var import_build_utils9 = require("@vercel/build-utils");
 
 // src/start-dev-server.ts
-var import_child_process = require("child_process");
-var import_fs3 = require("fs");
-var import_path4 = require("path");
-var import_build_utils6 = require("@vercel/build-utils");
+var import_child_process2 = require("child_process");
+var import_fs4 = require("fs");
+var import_path6 = require("path");
+var import_build_utils7 = require("@vercel/build-utils");
 
 // src/entrypoint.ts
-var import_path3 = require("path");
-var import_build_utils4 = require("@vercel/build-utils");
+var import_path5 = require("path");
 var import_build_utils5 = require("@vercel/build-utils");
+var import_build_utils6 = require("@vercel/build-utils");
 var PYTHON_ENTRYPOINT_FILENAMES = [
   "app",
   "index",
@@ -3798,11 +3862,11 @@ var PYTHON_ENTRYPOINT_FILENAMES = [
 var PYTHON_ENTRYPOINT_DIRS = ["", "src", "app", "api"];
 var PYTHON_CANDIDATE_ENTRYPOINTS = PYTHON_ENTRYPOINT_FILENAMES.flatMap(
   (filename) => PYTHON_ENTRYPOINT_DIRS.map(
-    (dir) => import_path3.posix.join(dir, `${filename}.py`)
+    (dir) => import_path5.posix.join(dir, `${filename}.py`)
   )
 );
 async function getPyprojectEntrypoint(workPath) {
-  const pyprojectData = await (0, import_build_utils5.readConfigFile)((0, import_path3.join)(workPath, "pyproject.toml"));
+  const pyprojectData = await (0, import_build_utils6.readConfigFile)((0, import_path5.join)(workPath, "pyproject.toml"));
   if (!pyprojectData)
     return null;
   const scripts = pyprojectData.project?.scripts;
@@ -3815,7 +3879,7 @@ async function getPyprojectEntrypoint(workPath) {
   const modulePath = match[1];
   const relPath = modulePath.replace(/\./g, "/");
   try {
-    const fsFiles = await (0, import_build_utils4.glob)("**", workPath);
+    const fsFiles = await (0, import_build_utils5.glob)("**", workPath);
     const candidates = [`${relPath}.py`, `${relPath}/__init__.py`];
     for (const candidate of candidates) {
       if (fsFiles[candidate])
@@ -3823,18 +3887,18 @@ async function getPyprojectEntrypoint(workPath) {
     }
     return null;
   } catch {
-    (0, import_build_utils4.debug)("Failed to discover Python entrypoint from pyproject.toml");
+    (0, import_build_utils5.debug)("Failed to discover Python entrypoint from pyproject.toml");
     return null;
   }
 }
 async function detectGenericPythonEntrypoint(workPath, configuredEntrypoint) {
   const entry = configuredEntrypoint.endsWith(".py") ? configuredEntrypoint : `${configuredEntrypoint}.py`;
   try {
-    const fsFiles = await (0, import_build_utils4.glob)("**", workPath);
+    const fsFiles = await (0, import_build_utils5.glob)("**", workPath);
     if (fsFiles[entry]) {
-      const isValid = await (0, import_build_utils4.isPythonEntrypoint)(fsFiles[entry]);
+      const isValid = await (0, import_build_utils5.isPythonEntrypoint)(fsFiles[entry]);
       if (isValid) {
-        (0, import_build_utils4.debug)(`Using configured Python entrypoint: ${entry}`);
+        (0, import_build_utils5.debug)(`Using configured Python entrypoint: ${entry}`);
         return entry;
       }
     }
@@ -3842,15 +3906,15 @@ async function detectGenericPythonEntrypoint(workPath, configuredEntrypoint) {
       (c) => !!fsFiles[c]
     );
     for (const candidate of candidates) {
-      const isValid = await (0, import_build_utils4.isPythonEntrypoint)(fsFiles[candidate]);
+      const isValid = await (0, import_build_utils5.isPythonEntrypoint)(fsFiles[candidate]);
       if (isValid) {
-        (0, import_build_utils4.debug)(`Detected Python entrypoint: ${candidate}`);
+        (0, import_build_utils5.debug)(`Detected Python entrypoint: ${candidate}`);
         return candidate;
       }
     }
     return null;
   } catch {
-    (0, import_build_utils4.debug)("Failed to discover Python entrypoint");
+    (0, import_build_utils5.debug)("Failed to discover Python entrypoint");
     return null;
   }
 }
@@ -3907,12 +3971,12 @@ function installGlobalCleanupHandlers() {
       try {
         process.kill(info.pid, "SIGTERM");
       } catch (err) {
-        (0, import_build_utils6.debug)(`Error sending SIGTERM to ${info.pid}: ${err}`);
+        (0, import_build_utils7.debug)(`Error sending SIGTERM to ${info.pid}: ${err}`);
       }
       try {
         process.kill(info.pid, "SIGKILL");
       } catch (err) {
-        (0, import_build_utils6.debug)(`Error sending SIGKILL to ${info.pid}: ${err}`);
+        (0, import_build_utils7.debug)(`Error sending SIGKILL to ${info.pid}: ${err}`);
       }
       PERSISTENT_SERVERS.delete(key);
     }
@@ -3920,7 +3984,7 @@ function installGlobalCleanupHandlers() {
       try {
         restoreWarnings();
       } catch (err) {
-        (0, import_build_utils6.debug)(`Error restoring warnings: ${err}`);
+        (0, import_build_utils7.debug)(`Error restoring warnings: ${err}`);
       }
       restoreWarnings = null;
     }
@@ -3939,33 +4003,33 @@ function installGlobalCleanupHandlers() {
 }
 function createDevAsgiShim(workPath, modulePath) {
   try {
-    const vercelPythonDir = (0, import_path4.join)(workPath, ".vercel", "python");
-    (0, import_fs3.mkdirSync)(vercelPythonDir, { recursive: true });
-    const shimPath = (0, import_path4.join)(vercelPythonDir, `${ASGI_SHIM_MODULE}.py`);
-    const templatePath = (0, import_path4.join)(__dirname, "..", `${ASGI_SHIM_MODULE}.py`);
-    const template = (0, import_fs3.readFileSync)(templatePath, "utf8");
+    const vercelPythonDir = (0, import_path6.join)(workPath, ".vercel", "python");
+    (0, import_fs4.mkdirSync)(vercelPythonDir, { recursive: true });
+    const shimPath = (0, import_path6.join)(vercelPythonDir, `${ASGI_SHIM_MODULE}.py`);
+    const templatePath = (0, import_path6.join)(__dirname, "..", `${ASGI_SHIM_MODULE}.py`);
+    const template = (0, import_fs4.readFileSync)(templatePath, "utf8");
     const shimSource = template.replace(/__VC_DEV_MODULE_PATH__/g, modulePath);
-    (0, import_fs3.writeFileSync)(shimPath, shimSource, "utf8");
-    (0, import_build_utils6.debug)(`Prepared Python dev static shim at ${shimPath}`);
+    (0, import_fs4.writeFileSync)(shimPath, shimSource, "utf8");
+    (0, import_build_utils7.debug)(`Prepared Python dev static shim at ${shimPath}`);
     return ASGI_SHIM_MODULE;
   } catch (err) {
-    (0, import_build_utils6.debug)(`Failed to prepare dev static shim: ${err?.message || err}`);
+    (0, import_build_utils7.debug)(`Failed to prepare dev static shim: ${err?.message || err}`);
     return null;
   }
 }
 function createDevWsgiShim(workPath, modulePath) {
   try {
-    const vercelPythonDir = (0, import_path4.join)(workPath, ".vercel", "python");
-    (0, import_fs3.mkdirSync)(vercelPythonDir, { recursive: true });
-    const shimPath = (0, import_path4.join)(vercelPythonDir, `${WSGI_SHIM_MODULE}.py`);
-    const templatePath = (0, import_path4.join)(__dirname, "..", `${WSGI_SHIM_MODULE}.py`);
-    const template = (0, import_fs3.readFileSync)(templatePath, "utf8");
+    const vercelPythonDir = (0, import_path6.join)(workPath, ".vercel", "python");
+    (0, import_fs4.mkdirSync)(vercelPythonDir, { recursive: true });
+    const shimPath = (0, import_path6.join)(vercelPythonDir, `${WSGI_SHIM_MODULE}.py`);
+    const templatePath = (0, import_path6.join)(__dirname, "..", `${WSGI_SHIM_MODULE}.py`);
+    const template = (0, import_fs4.readFileSync)(templatePath, "utf8");
     const shimSource = template.replace(/__VC_DEV_MODULE_PATH__/g, modulePath);
-    (0, import_fs3.writeFileSync)(shimPath, shimSource, "utf8");
-    (0, import_build_utils6.debug)(`Prepared Python dev WSGI shim at ${shimPath}`);
+    (0, import_fs4.writeFileSync)(shimPath, shimSource, "utf8");
+    (0, import_build_utils7.debug)(`Prepared Python dev WSGI shim at ${shimPath}`);
     return WSGI_SHIM_MODULE;
   } catch (err) {
-    (0, import_build_utils6.debug)(`Failed to prepare dev WSGI shim: ${err?.message || err}`);
+    (0, import_build_utils7.debug)(`Failed to prepare dev WSGI shim: ${err?.message || err}`);
     return null;
   }
 }
@@ -3985,7 +4049,7 @@ var startDevServer = async (opts) => {
   );
   if (!entry) {
     const searched = PYTHON_CANDIDATE_ENTRYPOINTS.join(", ");
-    throw new import_build_utils6.NowBuildError({
+    throw new import_build_utils7.NowBuildError({
       code: "PYTHON_ENTRYPOINT_NOT_FOUND",
       message: `No ${framework} entrypoint found. Add an 'app' script in pyproject.toml or define an entrypoint in one of: ${searched}.`,
       link: `https://vercel.com/docs/frameworks/backend/${framework?.toLowerCase()}#exporting-the-${framework?.toLowerCase()}-application`,
@@ -4031,11 +4095,11 @@ var startDevServer = async (opts) => {
   try {
     await new Promise((resolve2, reject) => {
       let resolved = false;
-      const { pythonPath: systemPython } = getLatestPythonVersion(meta);
+      const { pythonPath: systemPython } = getDefaultPythonVersion(meta);
       let pythonCmd = systemPython;
       const venv = isInVirtualEnv();
       if (venv) {
-        (0, import_build_utils6.debug)(`Running in virtualenv at ${venv}`);
+        (0, import_build_utils7.debug)(`Running in virtualenv at ${venv}`);
       } else {
         const { pythonCmd: venvPythonCmd, venvRoot } = useVirtualEnv(
           workPath,
@@ -4044,9 +4108,9 @@ var startDevServer = async (opts) => {
         );
         pythonCmd = venvPythonCmd;
         if (venvRoot) {
-          (0, import_build_utils6.debug)(`Using virtualenv at ${venvRoot}`);
+          (0, import_build_utils7.debug)(`Using virtualenv at ${venvRoot}`);
         } else {
-          (0, import_build_utils6.debug)("No virtualenv found");
+          (0, import_build_utils7.debug)("No virtualenv found");
           try {
             const yellow = "\x1B[33m";
             const reset = "\x1B[0m";
@@ -4063,16 +4127,16 @@ If you are using a virtual environment, activate it before running "vercel dev",
       if (framework !== "flask") {
         const devShimModule = createDevAsgiShim(workPath, modulePath);
         if (devShimModule) {
-          const vercelPythonDir = (0, import_path4.join)(workPath, ".vercel", "python");
+          const vercelPythonDir = (0, import_path6.join)(workPath, ".vercel", "python");
           const existingPythonPath = env.PYTHONPATH || "";
           env.PYTHONPATH = existingPythonPath ? `${vercelPythonDir}:${existingPythonPath}` : vercelPythonDir;
         }
         const moduleToRun = devShimModule || modulePath;
         const argv = ["-u", "-m", moduleToRun];
-        (0, import_build_utils6.debug)(
+        (0, import_build_utils7.debug)(
           `Starting ASGI dev server (${framework}): ${pythonCmd} ${argv.join(" ")}`
         );
-        const child = (0, import_child_process.spawn)(pythonCmd, argv, {
+        const child = (0, import_child_process2.spawn)(pythonCmd, argv, {
           cwd: workPath,
           env,
           stdio: ["inherit", "pipe", "pipe"]
@@ -4143,14 +4207,14 @@ If you are using a virtual environment, activate it before running "vercel dev",
       } else {
         const devShimModule = createDevWsgiShim(workPath, modulePath);
         if (devShimModule) {
-          const vercelPythonDir = (0, import_path4.join)(workPath, ".vercel", "python");
+          const vercelPythonDir = (0, import_path6.join)(workPath, ".vercel", "python");
           const existingPythonPath = env.PYTHONPATH || "";
           env.PYTHONPATH = existingPythonPath ? `${vercelPythonDir}:${existingPythonPath}` : vercelPythonDir;
         }
         const moduleToRun = devShimModule || modulePath;
         const argv = ["-u", "-m", moduleToRun];
-        (0, import_build_utils6.debug)(`Starting Flask dev server: ${pythonCmd} ${argv.join(" ")}`);
-        const child = (0, import_child_process.spawn)(pythonCmd, argv, {
+        (0, import_build_utils7.debug)(`Starting Flask dev server: ${pythonCmd} ${argv.join(" ")}`);
+        const child = (0, import_child_process2.spawn)(pythonCmd, argv, {
           cwd: workPath,
           env,
           stdio: ["inherit", "pipe", "pipe"]
@@ -4236,8 +4300,8 @@ If you are using a virtual environment, activate it before running "vercel dev",
 };
 
 // src/index.ts
-var readFile = (0, import_util.promisify)(import_fs4.default.readFile);
-var writeFile = (0, import_util.promisify)(import_fs4.default.writeFile);
+var readFile = (0, import_util.promisify)(import_fs5.default.readFile);
+var writeFile = (0, import_util.promisify)(import_fs5.default.writeFile);
 var version = 3;
 async function downloadFilesInWorkPath({
   entrypoint,
@@ -4245,13 +4309,13 @@ async function downloadFilesInWorkPath({
   files,
   meta = {}
 }) {
-  (0, import_build_utils7.debug)("Downloading user files...");
-  let downloadedFiles = await (0, import_build_utils7.download)(files, workPath, meta);
+  (0, import_build_utils8.debug)("Downloading user files...");
+  let downloadedFiles = await (0, import_build_utils8.download)(files, workPath, meta);
   if (meta.isDev) {
-    const { devCacheDir = (0, import_path5.join)(workPath, ".now", "cache") } = meta;
-    const destCache = (0, import_path5.join)(devCacheDir, (0, import_path5.basename)(entrypoint, ".py"));
-    await (0, import_build_utils7.download)(downloadedFiles, destCache);
-    downloadedFiles = await (0, import_build_utils7.glob)("**", destCache);
+    const { devCacheDir = (0, import_path7.join)(workPath, ".now", "cache") } = meta;
+    const destCache = (0, import_path7.join)(devCacheDir, (0, import_path7.basename)(entrypoint, ".py"));
+    await (0, import_build_utils8.download)(downloadedFiles, destCache);
+    downloadedFiles = await (0, import_build_utils8.glob)("**", destCache);
     workPath = destCache;
   }
   return workPath;
@@ -4275,21 +4339,21 @@ var build = async ({
   });
   try {
     if (meta.isDev) {
-      const setupCfg = (0, import_path5.join)(workPath, "setup.cfg");
+      const setupCfg = (0, import_path7.join)(workPath, "setup.cfg");
       await writeFile(setupCfg, "[install]\nprefix=\n");
     }
   } catch (err) {
     console.log('Failed to create "setup.cfg" file');
     throw err;
   }
-  if ((0, import_build_utils7.isPythonFramework)(framework)) {
+  if ((0, import_build_utils8.isPythonFramework)(framework)) {
     const {
       cliType,
       lockfileVersion,
       packageJsonPackageManager,
       turboSupportsCorepackHome
-    } = await (0, import_build_utils7.scanParentDirs)(workPath, true);
-    spawnEnv = (0, import_build_utils7.getEnvForPackageManager)({
+    } = await (0, import_build_utils8.scanParentDirs)(workPath, true);
+    spawnEnv = (0, import_build_utils8.getEnvForPackageManager)({
       cliType,
       lockfileVersion,
       packageJsonPackageManager,
@@ -4310,7 +4374,7 @@ var build = async ({
     config?.buildCommand;
     if (projectBuildCommand) {
       console.log(`Running "${projectBuildCommand}"`);
-      await (0, import_build_utils7.execCommand)(projectBuildCommand, {
+      await (0, import_build_utils8.execCommand)(projectBuildCommand, {
         env: spawnEnv,
         cwd: workPath
       });
@@ -4322,21 +4386,21 @@ var build = async ({
       );
     }
   }
-  let fsFiles = await (0, import_build_utils7.glob)("**", workPath);
-  if ((0, import_build_utils7.isPythonFramework)(framework) && (!fsFiles[entrypoint] || !entrypoint.endsWith(".py"))) {
+  let fsFiles = await (0, import_build_utils8.glob)("**", workPath);
+  if ((0, import_build_utils8.isPythonFramework)(framework) && (!fsFiles[entrypoint] || !entrypoint.endsWith(".py"))) {
     const detected = await detectPythonEntrypoint(
       config.framework,
       workPath,
       entrypoint
     );
     if (detected) {
-      (0, import_build_utils7.debug)(
+      (0, import_build_utils8.debug)(
         `Resolved Python entrypoint to "${detected}" (configured "${entrypoint}" not found).`
       );
       entrypoint = detected;
     } else {
       const searchedList = PYTHON_CANDIDATE_ENTRYPOINTS.join(", ");
-      throw new import_build_utils7.NowBuildError({
+      throw new import_build_utils8.NowBuildError({
         code: `${framework.toUpperCase()}_ENTRYPOINT_NOT_FOUND`,
         message: `No ${framework} entrypoint found. Add an 'app' script in pyproject.toml or define an entrypoint in one of: ${searchedList}.`,
         link: `https://vercel.com/docs/frameworks/backend/${framework}#exporting-the-${framework}-application`,
@@ -4344,7 +4408,7 @@ var build = async ({
       });
     }
   }
-  const entryDirectory = (0, import_path5.dirname)(entrypoint);
+  const entryDirectory = (0, import_path7.dirname)(entrypoint);
   const pyprojectDir = findDir({
     file: "pyproject.toml",
     entryDirectory,
@@ -4357,29 +4421,51 @@ var build = async ({
     workPath,
     fsFiles
   });
+  const pythonVersionFileDir = findDir({
+    file: ".python-version",
+    entryDirectory,
+    workPath,
+    fsFiles
+  });
   let declaredPythonVersion;
-  if (pyprojectDir) {
+  if (pythonVersionFileDir) {
+    try {
+      const content = await readFile(
+        (0, import_path7.join)(pythonVersionFileDir, ".python-version"),
+        "utf8"
+      );
+      const version2 = parsePythonVersionFile(content);
+      if (version2) {
+        declaredPythonVersion = { version: version2, source: ".python-version" };
+        (0, import_build_utils8.debug)(`Found Python version ${version2} in .python-version`);
+      }
+    } catch (err) {
+      (0, import_build_utils8.debug)("Failed to read .python-version file", err);
+    }
+  }
+  if (!declaredPythonVersion && pyprojectDir) {
     let requiresPython;
     try {
-      const pyproject = await (0, import_build_utils8.readConfigFile)((0, import_path5.join)(pyprojectDir, "pyproject.toml"));
+      const pyproject = await (0, import_build_utils9.readConfigFile)((0, import_path7.join)(pyprojectDir, "pyproject.toml"));
       requiresPython = pyproject?.project?.["requires-python"];
     } catch (err) {
-      (0, import_build_utils7.debug)("Failed to parse pyproject.toml", err);
+      (0, import_build_utils8.debug)("Failed to parse pyproject.toml", err);
     }
     if (typeof requiresPython === "string" && requiresPython.trim()) {
       declaredPythonVersion = {
         version: requiresPython.trim(),
         source: "pyproject.toml"
       };
-      (0, import_build_utils7.debug)(`Found requires-python "${requiresPython}" in pyproject.toml`);
+      (0, import_build_utils8.debug)(`Found requires-python "${requiresPython}" in pyproject.toml`);
     }
-  } else if (pipfileLockDir) {
+  }
+  if (!declaredPythonVersion && pipfileLockDir) {
     let lock = {};
     try {
-      const json = await readFile((0, import_path5.join)(pipfileLockDir, "Pipfile.lock"), "utf8");
+      const json = await readFile((0, import_path7.join)(pipfileLockDir, "Pipfile.lock"), "utf8");
       lock = JSON.parse(json);
     } catch (err) {
-      throw new import_build_utils7.NowBuildError({
+      throw new import_build_utils8.NowBuildError({
         code: "INVALID_PIPFILE_LOCK",
         message: "Unable to parse Pipfile.lock"
       });
@@ -4387,20 +4473,30 @@ var build = async ({
     const pyFromLock = lock?._meta?.requires?.python_version;
     if (pyFromLock) {
       declaredPythonVersion = { version: pyFromLock, source: "Pipfile.lock" };
-      (0, import_build_utils7.debug)(`Found Python version ${pyFromLock} in Pipfile.lock`);
+      (0, import_build_utils8.debug)(`Found Python version ${pyFromLock} in Pipfile.lock`);
     }
   }
   const pythonVersion = getSupportedPythonVersion({
     isDev: meta.isDev,
     declaredPythonVersion
   });
-  fsFiles = await (0, import_build_utils7.glob)("**", workPath);
-  const venvPath = (0, import_path5.join)(workPath, ".vercel", "python", ".venv");
+  const selectedVersionTuple = parseVersionTuple(pythonVersion.version);
+  const defaultVersionTuple = parseVersionTuple(DEFAULT_PYTHON_VERSION);
+  if (!pythonVersionFileDir && pyprojectDir && declaredPythonVersion?.source === "pyproject.toml" && selectedVersionTuple && defaultVersionTuple && compareTuples(selectedVersionTuple, defaultVersionTuple) <= 0) {
+    const pythonVersionFilePath = (0, import_path7.join)(pyprojectDir, ".python-version");
+    await writeFile(pythonVersionFilePath, `${pythonVersion.version}
+`);
+    console.log(
+      `Writing .python-version file with version ${pythonVersion.version}`
+    );
+  }
+  fsFiles = await (0, import_build_utils8.glob)("**", workPath);
+  const venvPath = (0, import_path7.join)(workPath, ".vercel", "python", ".venv");
   await ensureVenv({
     pythonPath: pythonVersion.pythonPath,
     venvPath
   });
-  const hasCustomInstallCommand = (0, import_build_utils7.isPythonFramework)(framework) && !!projectInstallCommand;
+  const hasCustomInstallCommand = (0, import_build_utils8.isPythonFramework)(framework) && !!projectInstallCommand;
   let useRuntime = false;
   if (hasCustomInstallCommand) {
     const baseEnv = spawnEnv || process.env;
@@ -4408,13 +4504,13 @@ var build = async ({
     pythonEnv.VERCEL_PYTHON_VENV_PATH = venvPath;
     const installCommand = projectInstallCommand;
     console.log(`Running "install" command: \`${installCommand}\`...`);
-    await (0, import_build_utils7.execCommand)(installCommand, {
+    await (0, import_build_utils8.execCommand)(installCommand, {
       env: pythonEnv,
       cwd: workPath
     });
   } else {
     let ranPyprojectInstall = false;
-    if ((0, import_build_utils7.isPythonFramework)(framework)) {
+    if ((0, import_build_utils8.isPythonFramework)(framework)) {
       const baseEnv = spawnEnv || process.env;
       const pythonEnv = createVenvEnv(venvPath, baseEnv);
       pythonEnv.VERCEL_PYTHON_VENV_PATH = venvPath;
@@ -4427,10 +4523,11 @@ var build = async ({
       );
     }
     if (!ranPyprojectInstall) {
-      let uvPath;
+      let uv;
       try {
-        uvPath = await getUvBinaryOrInstall(pythonVersion.pythonPath);
+        const uvPath = await getUvBinaryOrInstall(pythonVersion.pythonPath);
         console.log(`Using uv at "${uvPath}"`);
+        uv = new UvRunner(uvPath);
       } catch (err) {
         console.log("Failed to install or locate uv");
         throw new Error(
@@ -4456,25 +4553,24 @@ var build = async ({
         repoRootPath,
         pythonPath: pythonVersion.pythonPath,
         pipPath: pythonVersion.pipPath,
-        uvPath,
+        uv,
         venvPath,
         meta,
         runtimeDependencies
       });
-      await runUvSync({
-        uvPath,
+      await uv.sync({
         venvPath,
         projectDir,
         locked: true
       });
     }
   }
-  (0, import_build_utils7.debug)("Entrypoint is", entrypoint);
+  (0, import_build_utils8.debug)("Entrypoint is", entrypoint);
   const moduleName = entrypoint.replace(/\//g, ".").replace(/\.py$/i, "");
   const vendorDir = resolveVendorDir();
   const suffix = meta.isDev && !entrypoint.endsWith(".py") ? ".py" : "";
   const entrypointWithSuffix = `${entrypoint}${suffix}`;
-  (0, import_build_utils7.debug)("Entrypoint with suffix is", entrypointWithSuffix);
+  (0, import_build_utils8.debug)("Entrypoint with suffix is", entrypointWithSuffix);
   let handlerPyContents;
   if (useRuntime) {
     handlerPyContents = `
@@ -4516,7 +4612,7 @@ if os.path.isdir(_vendor):
 from vercel_runtime.vc_init import vc_handler
 `;
   } else {
-    const originalPyPath = (0, import_path5.join)(__dirname, "..", "vc_init.py");
+    const originalPyPath = (0, import_path7.join)(__dirname, "..", "vc_init.py");
     const originalHandlerPyContents = await readFile(originalPyPath, "utf8");
     handlerPyContents = originalHandlerPyContents.replace(/__VC_HANDLER_MODULE_NAME/g, moduleName).replace(/__VC_HANDLER_ENTRYPOINT/g, entrypointWithSuffix).replace(/__VC_HANDLER_VENDOR_DIR/g, vendorDir);
   }
@@ -4544,7 +4640,7 @@ from vercel_runtime.vc_init import vc_handler
     cwd: workPath,
     ignore: config && typeof config.excludeFiles === "string" ? [...predefinedExcludes, config.excludeFiles] : predefinedExcludes
   };
-  const files = await (0, import_build_utils7.glob)("**", globOptions);
+  const files = await (0, import_build_utils8.glob)("**", globOptions);
   const vendorFiles = await mirrorSitePackagesIntoVendor({
     venvPath,
     vendorDirName: vendorDir
@@ -4553,12 +4649,12 @@ from vercel_runtime.vc_init import vc_handler
     files[p] = f;
   }
   const handlerPyFilename = "vc__handler__python";
-  files[`${handlerPyFilename}.py`] = new import_build_utils7.FileBlob({ data: handlerPyContents });
+  files[`${handlerPyFilename}.py`] = new import_build_utils8.FileBlob({ data: handlerPyContents });
   if (config.framework === "fasthtml") {
     const { SESSKEY = "" } = process.env;
-    files[".sesskey"] = new import_build_utils7.FileBlob({ data: `"${SESSKEY}"` });
+    files[".sesskey"] = new import_build_utils8.FileBlob({ data: `"${SESSKEY}"` });
   }
-  const output = new import_build_utils7.Lambda({
+  const output = new import_build_utils8.Lambda({
     files,
     handler: `${handlerPyFilename}.vc_handler`,
     runtime: pythonVersion.runtime,
@@ -4594,7 +4690,7 @@ var defaultShouldServe = ({
   if (entrypoint === requestPath && hasProp(files, entrypoint)) {
     return true;
   }
-  const { dir, name } = (0, import_path5.parse)(entrypoint);
+  const { dir, name } = (0, import_path7.parse)(entrypoint);
   if (name === "index" && dir === requestPath && hasProp(files, entrypoint)) {
     return true;
   }
@@ -4603,6 +4699,16 @@ var defaultShouldServe = ({
 function hasProp(obj, key) {
   return Object.hasOwnProperty.call(obj, key);
 }
+function parsePythonVersionFile(content) {
+  const lines = content.split("\n");
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#"))
+      continue;
+    return trimmed;
+  }
+  return void 0;
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   build,