@vercel/python 6.20.1 → 6.21.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 fs8 = require("fs");
+    var fs9 = 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) {
-      fs8.stat(path, function(er, stat) {
+      fs9.stat(path, function(er, stat) {
         cb(er, er ? false : checkStat(stat, path, options));
       });
     }
     function sync(path, options) {
-      return checkStat(fs8.statSync(path), path, options);
+      return checkStat(fs9.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 fs8 = require("fs");
+    var fs9 = require("fs");
     function isexe(path, options, cb) {
-      fs8.stat(path, function(er, stat) {
+      fs9.stat(path, function(er, stat) {
         cb(er, er ? false : checkStat(stat, options));
       });
     }
     function sync(path, options) {
-      return checkStat(fs8.statSync(path), options);
+      return checkStat(fs9.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 fs8 = require("fs");
+    var fs9 = require("fs");
     var core;
     if (process.platform === "win32" || global.TESTING_WINDOWS) {
       core = require_windows();
@@ -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 fs8 = require("fs");
+    var fs9 = 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 = fs8.openSync(command, "r");
-        fs8.readSync(fd, buffer, 0, size, 0);
-        fs8.closeSync(fd);
+        fd = fs9.openSync(command, "r");
+        fs9.readSync(fd, buffer, 0, size, 0);
+        fs9.closeSync(fd);
       } catch (e) {
       }
       return shebangCommand(buffer.toString());
@@ -423,15 +423,15 @@ var require_readShebang = __commonJS({
 var require_semver = __commonJS({
   "../../node_modules/.pnpm/semver@5.7.2/node_modules/semver/semver.js"(exports, module2) {
     exports = module2.exports = SemVer;
-    var debug10;
+    var debug11;
     if (typeof process === "object" && process.env && process.env.NODE_DEBUG && /\bsemver\b/i.test(process.env.NODE_DEBUG)) {
-      debug10 = function() {
+      debug11 = function() {
         var args = Array.prototype.slice.call(arguments, 0);
         args.unshift("SEMVER");
         console.log.apply(console, args);
       };
     } else {
-      debug10 = function() {
+      debug11 = function() {
       };
     }
     exports.SEMVER_SPEC_VERSION = "2.0.0";
@@ -540,7 +540,7 @@ var require_semver = __commonJS({
     var STAR = R++;
     src[STAR] = "(<|>)?=?\\s*\\*";
     for (i = 0; i < R; i++) {
-      debug10(i, src[i]);
+      debug11(i, src[i]);
       if (!re[i]) {
         re[i] = new RegExp(src[i]);
         safeRe[i] = new RegExp(makeSafeRe(src[i]));
@@ -607,7 +607,7 @@ var require_semver = __commonJS({
       if (!(this instanceof SemVer)) {
         return new SemVer(version2, options);
       }
-      debug10("SemVer", version2, options);
+      debug11("SemVer", version2, options);
       this.options = options;
       this.loose = !!options.loose;
       var m = version2.trim().match(options.loose ? safeRe[LOOSE] : safeRe[FULL]);
@@ -654,7 +654,7 @@ var require_semver = __commonJS({
       return this.version;
     };
     SemVer.prototype.compare = function(other) {
-      debug10("SemVer.compare", this.version, this.options, other);
+      debug11("SemVer.compare", this.version, this.options, other);
       if (!(other instanceof SemVer)) {
         other = new SemVer(other, this.options);
       }
@@ -681,7 +681,7 @@ var require_semver = __commonJS({
       do {
         var a = this.prerelease[i2];
         var b = other.prerelease[i2];
-        debug10("prerelease compare", i2, a, b);
+        debug11("prerelease compare", i2, a, b);
         if (a === void 0 && b === void 0) {
           return 0;
         } else if (b === void 0) {
@@ -935,7 +935,7 @@ var require_semver = __commonJS({
         return new Comparator(comp, options);
       }
       comp = comp.trim().split(/\s+/).join(" ");
-      debug10("comparator", comp, options);
+      debug11("comparator", comp, options);
       this.options = options;
       this.loose = !!options.loose;
       this.parse(comp);
@@ -944,7 +944,7 @@ var require_semver = __commonJS({
       } else {
         this.value = this.operator + this.semver.version;
       }
-      debug10("comp", this);
+      debug11("comp", this);
     }
     var ANY = {};
     Comparator.prototype.parse = function(comp) {
@@ -967,7 +967,7 @@ var require_semver = __commonJS({
       return this.value;
     };
     Comparator.prototype.test = function(version2) {
-      debug10("Comparator.test", version2, this.options.loose);
+      debug11("Comparator.test", version2, this.options.loose);
       if (this.semver === ANY) {
         return true;
       }
@@ -989,10 +989,10 @@ var require_semver = __commonJS({
       var rangeTmp;
       if (this.operator === "") {
         rangeTmp = new Range(comp.value, options);
-        return satisfies2(this.value, rangeTmp, options);
+        return satisfies(this.value, rangeTmp, options);
       } else if (comp.operator === "") {
         rangeTmp = new Range(this.value, options);
-        return satisfies2(comp.semver, rangeTmp, options);
+        return satisfies(comp.semver, rangeTmp, options);
       }
       var sameDirectionIncreasing = (this.operator === ">=" || this.operator === ">") && (comp.operator === ">=" || comp.operator === ">");
       var sameDirectionDecreasing = (this.operator === "<=" || this.operator === "<") && (comp.operator === "<=" || comp.operator === "<");
@@ -1050,9 +1050,9 @@ var require_semver = __commonJS({
       var loose = this.options.loose;
       var hr = loose ? safeRe[HYPHENRANGELOOSE] : safeRe[HYPHENRANGE];
       range = range.replace(hr, hyphenReplace);
-      debug10("hyphen replace", range);
+      debug11("hyphen replace", range);
       range = range.replace(safeRe[COMPARATORTRIM], comparatorTrimReplace);
-      debug10("comparator trim", range, safeRe[COMPARATORTRIM]);
+      debug11("comparator trim", range, safeRe[COMPARATORTRIM]);
       range = range.replace(safeRe[TILDETRIM], tildeTrimReplace);
       range = range.replace(safeRe[CARETTRIM], caretTrimReplace);
       var compRe = loose ? safeRe[COMPARATORLOOSE] : safeRe[COMPARATOR];
@@ -1092,15 +1092,15 @@ var require_semver = __commonJS({
       });
     }
     function parseComparator(comp, options) {
-      debug10("comp", comp, options);
+      debug11("comp", comp, options);
       comp = replaceCarets(comp, options);
-      debug10("caret", comp);
+      debug11("caret", comp);
       comp = replaceTildes(comp, options);
-      debug10("tildes", comp);
+      debug11("tildes", comp);
       comp = replaceXRanges(comp, options);
-      debug10("xrange", comp);
+      debug11("xrange", comp);
       comp = replaceStars(comp, options);
-      debug10("stars", comp);
+      debug11("stars", comp);
       return comp;
     }
     function isX(id) {
@@ -1114,7 +1114,7 @@ var require_semver = __commonJS({
     function replaceTilde(comp, options) {
       var r = options.loose ? safeRe[TILDELOOSE] : safeRe[TILDE];
       return comp.replace(r, function(_, M, m, p, pr) {
-        debug10("tilde", comp, _, M, m, p, pr);
+        debug11("tilde", comp, _, M, m, p, pr);
         var ret;
         if (isX(M)) {
           ret = "";
@@ -1123,12 +1123,12 @@ var require_semver = __commonJS({
         } else if (isX(p)) {
           ret = ">=" + M + "." + m + ".0 <" + M + "." + (+m + 1) + ".0";
         } else if (pr) {
-          debug10("replaceTilde pr", pr);
+          debug11("replaceTilde pr", pr);
           ret = ">=" + M + "." + m + "." + p + "-" + pr + " <" + M + "." + (+m + 1) + ".0";
         } else {
           ret = ">=" + M + "." + m + "." + p + " <" + M + "." + (+m + 1) + ".0";
         }
-        debug10("tilde return", ret);
+        debug11("tilde return", ret);
         return ret;
       });
     }
@@ -1138,10 +1138,10 @@ var require_semver = __commonJS({
       }).join(" ");
     }
     function replaceCaret(comp, options) {
-      debug10("caret", comp, options);
+      debug11("caret", comp, options);
       var r = options.loose ? safeRe[CARETLOOSE] : safeRe[CARET];
       return comp.replace(r, function(_, M, m, p, pr) {
-        debug10("caret", comp, _, M, m, p, pr);
+        debug11("caret", comp, _, M, m, p, pr);
         var ret;
         if (isX(M)) {
           ret = "";
@@ -1154,7 +1154,7 @@ var require_semver = __commonJS({
             ret = ">=" + M + "." + m + ".0 <" + (+M + 1) + ".0.0";
           }
         } else if (pr) {
-          debug10("replaceCaret pr", pr);
+          debug11("replaceCaret pr", pr);
           if (M === "0") {
             if (m === "0") {
               ret = ">=" + M + "." + m + "." + p + "-" + pr + " <" + M + "." + m + "." + (+p + 1);
@@ -1165,7 +1165,7 @@ var require_semver = __commonJS({
             ret = ">=" + M + "." + m + "." + p + "-" + pr + " <" + (+M + 1) + ".0.0";
           }
         } else {
-          debug10("no pr");
+          debug11("no pr");
           if (M === "0") {
             if (m === "0") {
               ret = ">=" + M + "." + m + "." + p + " <" + M + "." + m + "." + (+p + 1);
@@ -1176,12 +1176,12 @@ var require_semver = __commonJS({
             ret = ">=" + M + "." + m + "." + p + " <" + (+M + 1) + ".0.0";
           }
         }
-        debug10("caret return", ret);
+        debug11("caret return", ret);
         return ret;
       });
     }
     function replaceXRanges(comp, options) {
-      debug10("replaceXRanges", comp, options);
+      debug11("replaceXRanges", comp, options);
       return comp.split(/\s+/).map(function(comp2) {
         return replaceXRange(comp2, options);
       }).join(" ");
@@ -1190,7 +1190,7 @@ var require_semver = __commonJS({
       comp = comp.trim();
       var r = options.loose ? safeRe[XRANGELOOSE] : safeRe[XRANGE];
       return comp.replace(r, function(ret, gtlt, M, m, p, pr) {
-        debug10("xRange", comp, ret, gtlt, M, m, p, pr);
+        debug11("xRange", comp, ret, gtlt, M, m, p, pr);
         var xM = isX(M);
         var xm = xM || isX(m);
         var xp = xm || isX(p);
@@ -1233,12 +1233,12 @@ var require_semver = __commonJS({
         } else if (xp) {
           ret = ">=" + M + "." + m + ".0 <" + M + "." + (+m + 1) + ".0";
         }
-        debug10("xRange return", ret);
+        debug11("xRange return", ret);
         return ret;
       });
     }
     function replaceStars(comp, options) {
-      debug10("replaceStars", comp, options);
+      debug11("replaceStars", comp, options);
       return comp.trim().replace(safeRe[STAR], "");
     }
     function hyphenReplace($0, from, fM, fm, fp, fpr, fb, to, tM, tm, tp, tpr, tb) {
@@ -1286,7 +1286,7 @@ var require_semver = __commonJS({
       }
       if (version2.prerelease.length && !options.includePrerelease) {
         for (i2 = 0; i2 < set.length; i2++) {
-          debug10(set[i2].semver);
+          debug11(set[i2].semver);
           if (set[i2].semver === ANY) {
             continue;
           }
@@ -1301,8 +1301,8 @@ var require_semver = __commonJS({
       }
       return true;
     }
-    exports.satisfies = satisfies2;
-    function satisfies2(version2, range, options) {
+    exports.satisfies = satisfies;
+    function satisfies(version2, range, options) {
       try {
         range = new Range(range, options);
       } catch (er) {
@@ -1430,7 +1430,7 @@ var require_semver = __commonJS({
         default:
           throw new TypeError('Must provide a hilo val of "<" or ">"');
       }
-      if (satisfies2(version2, range, options)) {
+      if (satisfies(version2, range, options)) {
         return false;
       }
       for (var i2 = 0; i2 < range.set.length; ++i2) {
@@ -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 fs8;
+    var fs9;
     try {
-      fs8 = require("fs");
+      fs9 = require("fs");
     } catch (e) {
     }
     var noop = function() {
@@ -1909,9 +1909,9 @@ var require_pump = __commonJS({
     var isFS = function(stream) {
       if (!ancient)
         return false;
-      if (!fs8)
+      if (!fs9)
         return false;
-      return (stream instanceof (fs8.ReadStream || noop) || stream instanceof (fs8.WriteStream || noop)) && isFn(stream.close);
+      return (stream instanceof (fs9.ReadStream || noop) || stream instanceof (fs9.WriteStream || noop)) && isFn(stream.close);
     };
     var isRequest = function(stream) {
       return stream.setHeader && isFn(stream.abort);
@@ -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: join10, delimiter: delimiter2, sep: sep2, posix } = require("path");
+    var { join: join12, delimiter: delimiter2, sep: sep2, posix } = require("path");
     var isWindows = process.platform === "win32";
     var rSlash = new RegExp(`[${posix.sep}${sep2 === posix.sep ? "" : sep2}]`.replace(/(\\)/g, "\\$1"));
     var rRel = new RegExp(`^\\.${rSlash.source}`);
@@ -2680,7 +2680,7 @@ 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 + join10(pathPart, cmd);
+      return prefix + join12(pathPart, cmd);
     };
     var which2 = async (cmd, opt = {}) => {
       const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
@@ -2862,28 +2862,29 @@ __export(src_exports, {
   downloadFilesInWorkPath: () => downloadFilesInWorkPath,
   installRequirement: () => installRequirement,
   installRequirementsFile: () => installRequirementsFile,
+  prepareCache: () => prepareCache,
+  runFrameworkHook: () => runFrameworkHook,
   shouldServe: () => shouldServe,
   startDevServer: () => startDevServer,
   version: () => version
 });
 module.exports = __toCommonJS(src_exports);
-var import_fs8 = __toESM(require("fs"));
-var import_util2 = require("util");
-var import_path10 = require("path");
+var import_fs10 = __toESM(require("fs"));
+var import_path12 = require("path");
 
 // src/package-versions.ts
-var VERCEL_RUNTIME_VERSION = "0.5.5";
-var VERCEL_WORKERS_VERSION = "0.0.11";
+var VERCEL_RUNTIME_VERSION = "0.6.0";
+var VERCEL_WORKERS_VERSION = "0.0.12";
 
 // src/index.ts
-var import_build_utils12 = require("@vercel/build-utils");
+var import_build_utils13 = require("@vercel/build-utils");
 
 // src/install.ts
 var import_execa3 = __toESM(require_execa());
 var import_fs3 = __toESM(require("fs"));
-var import_path4 = require("path");
+var import_path5 = require("path");
 var import_build_utils4 = require("@vercel/build-utils");
-var import_python_analysis = require("@vercel/python-analysis");
+var import_python_analysis2 = require("@vercel/python-analysis");
 
 // src/utils.ts
 var import_fs2 = __toESM(require("fs"));
@@ -2903,14 +2904,19 @@ 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 UV_CACHE_DIR_SUBPATH = [".vercel", "python", "cache", "uv"];
 var isWin = process.platform === "win32";
 var uvExec = isWin ? "uv.exe" : "uv";
 function findUvInPath() {
   return import_which.default.sync("uv", { nothrow: true });
 }
+function getUvCacheDir(workPath) {
+  return (0, import_path.join)(workPath, ...UV_CACHE_DIR_SUBPATH);
+}
 var UvRunner = class {
-  constructor(uvPath) {
+  constructor(uvPath, uvCacheDir) {
     this.uvPath = uvPath;
+    this.uvCacheDir = uvCacheDir;
   }
   getPath() {
     return this.uvPath;
@@ -2987,7 +2993,7 @@ var UvRunner = class {
     try {
       await (0, import_execa.default)(this.uvPath, args, {
         cwd: projectDir,
-        env: getProtectedUvEnv(process.env)
+        env: getProtectedUvEnv(process.env, this.uvCacheDir)
       });
     } catch (err) {
       const error = new Error(
@@ -3052,7 +3058,7 @@ var UvRunner = class {
     const binDir = isWin ? (0, import_path.join)(venvPath, "Scripts") : (0, import_path.join)(venvPath, "bin");
     const existingPath = process.env.PATH || "";
     return {
-      ...getProtectedUvEnv(process.env),
+      ...getProtectedUvEnv(process.env, this.uvCacheDir),
       VIRTUAL_ENV: venvPath,
       PATH: existingPath ? `${binDir}${import_path2.delimiter}${existingPath}` : binDir
     };
@@ -3159,11 +3165,15 @@ async function getUvBinaryOrInstall(pythonPath) {
 function filterUnsafeUvPipArgs(args) {
   return args.filter((arg) => arg !== "--no-warn-script-location");
 }
-function getProtectedUvEnv(baseEnv = process.env) {
-  return {
+function getProtectedUvEnv(baseEnv = process.env, uvCacheDir) {
+  const env = {
     ...baseEnv,
     UV_PYTHON_DOWNLOADS: UV_PYTHON_DOWNLOADS_MODE
   };
+  if (uvCacheDir) {
+    env.UV_CACHE_DIR = uvCacheDir;
+  }
+  return env;
 }
 var UV_BUNDLE_DIR = "_uv";
 async function getUvBinaryForBundling(pythonPath) {
@@ -3202,9 +3212,9 @@ function useVirtualEnv(workPath, env, systemPython) {
   }
   return { pythonCmd };
 }
-function createVenvEnv(venvPath, baseEnv = process.env) {
+function createVenvEnv(venvPath, baseEnv = process.env, uvCacheDir) {
   const env = {
-    ...getProtectedUvEnv(baseEnv),
+    ...getProtectedUvEnv(baseEnv, uvCacheDir),
     VIRTUAL_ENV: venvPath
   };
   const binDir = getVenvBinDir(venvPath);
@@ -3216,6 +3226,7 @@ async function ensureVenv({
   pythonPath,
   venvPath,
   uvPath,
+  uvCacheDir,
   quiet
 }) {
   const marker = (0, import_path3.join)(venvPath, "pyvenv.cfg");
@@ -3229,7 +3240,9 @@ async function ensureVenv({
     console.log(`Creating virtual environment at "${venvPath}"...`);
   }
   if (uvPath) {
-    await (0, import_execa2.default)(uvPath, ["venv", venvPath]);
+    await (0, import_execa2.default)(uvPath, ["venv", venvPath], {
+      env: getProtectedUvEnv(process.env, uvCacheDir)
+    });
   } else {
     await (0, import_execa2.default)(pythonPath, ["-m", "venv", venvPath]);
   }
@@ -3269,72 +3282,41 @@ async function runPyprojectScript(workPath, scriptNames, env, useUserVirtualEnv
   }
   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_path4 = require("path");
 var import_build_utils3 = require("@vercel/build-utils");
-var DEFAULT_PYTHON_VERSION = "3.12";
+var import_python_analysis = require("@vercel/python-analysis");
+function pythonVersionString(pv) {
+  return `${pv.major}.${pv.minor}`;
+}
+var DEFAULT_PYTHON_VERSION = makePythonVersion(3, 12);
+var DEFAULT_PYTHON_VERSION_STRING = pythonVersionString(
+  DEFAULT_PYTHON_VERSION
+);
+function makePythonVersion(major, minor, discontinueDate) {
+  return {
+    major,
+    minor,
+    pipPath: `pip${major}.${minor}`,
+    pythonPath: `python${major}.${minor}`,
+    runtime: `python${major}.${minor}`,
+    discontinueDate
+  };
+}
 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")
-  }
+  makePythonVersion(3, 14),
+  makePythonVersion(3, 13),
+  makePythonVersion(3, 12),
+  makePythonVersion(3, 11),
+  makePythonVersion(3, 10),
+  makePythonVersion(3, 9),
+  makePythonVersion(3, 6, /* @__PURE__ */ new Date("2022-07-18"))
 ];
 function getDevPythonVersion() {
   return {
-    version: "3",
+    major: 3,
+    minor: 0,
     pipPath: "pip3",
     pythonPath: "python3",
     runtime: "python3"
@@ -3347,7 +3329,7 @@ function getDefaultPythonVersion({
     return getDevPythonVersion();
   }
   const defaultOption = allOptions.find(
-    (opt) => opt.version === DEFAULT_PYTHON_VERSION && isInstalled(opt)
+    (opt) => versionsEqual(opt, DEFAULT_PYTHON_VERSION) && isInstalled(opt)
   );
   if (defaultOption) {
     return defaultOption;
@@ -3362,148 +3344,143 @@ function getDefaultPythonVersion({
   }
   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 versionsEqual(a, b) {
+  return a.major === b.major && a.minor === b.minor;
 }
-function compareTuples(a, b) {
-  if (a[0] !== b[0])
-    return a[0] - b[0];
-  return a[1] - b[1];
+function versionLessOrEqual(a, b) {
+  if (a.major !== b.major)
+    return a.major < b.major;
+  return a.minor <= b.minor;
 }
-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 toPythonBuild(opt) {
+  return {
+    version: { major: opt.major, minor: opt.minor },
+    implementation: "cpython",
+    variant: "default",
+    os: "linux",
+    architecture: "x86_64",
+    libc: "gnu"
+  };
 }
-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 getAvailablePythonBuilds() {
+  const installed = allOptions.filter(
+    (opt) => !isDiscontinued(opt) && isInstalled(opt)
+  );
+  const defaultOpt = installed.find(
+    (opt) => versionsEqual(opt, DEFAULT_PYTHON_VERSION)
+  );
+  const rest = installed.filter(
+    (opt) => !versionsEqual(opt, DEFAULT_PYTHON_VERSION)
+  );
+  const ordered = defaultOpt ? [defaultOpt, ...rest] : rest;
+  return ordered.map(toPythonBuild);
 }
-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 defaultMatch = matches.find(
-    (opt) => opt.version === DEFAULT_PYTHON_VERSION && isInstalled(opt)
+function getAllPythonBuilds() {
+  return allOptions.map(toPythonBuild);
+}
+function getPythonVersionForBuild(build2) {
+  return allOptions.find(
+    (opt) => opt.major === build2.version.major && opt.minor === build2.version.minor
   );
-  if (defaultMatch) {
-    return defaultMatch;
-  }
-  const installedMatch = matches.find(isInstalled);
-  return installedMatch ?? matches[0];
 }
-function getSupportedPythonVersion({
+function resolvePythonVersion({
   isDev,
-  declaredPythonVersion
+  pythonPackage,
+  rootDir
 }) {
   if (isDev) {
-    return getDevPythonVersion();
+    return {
+      pythonVersion: getDevPythonVersion(),
+      pythonPackage
+    };
   }
-  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)) {
+  const constraints = pythonPackage.requiresPython;
+  const defaultPv = getDefaultPythonVersion({ isDev: false });
+  let selection;
+  let source;
+  let autoUpgraded = false;
+  if (!constraints || constraints.length === 0) {
+    console.log(
+      `No Python version specified in .python-version, pyproject.toml, or Pipfile.lock. Using python version: ${pythonVersionString(defaultPv)}`
+    );
+    selection = defaultPv;
+  } else {
+    const defaultBuild = toPythonBuild(defaultPv);
+    const availableBuilds = getAvailablePythonBuilds();
+    const allBuilds = getAllPythonBuilds();
+    const result = (0, import_python_analysis.selectPythonVersion)({
+      constraints,
+      availableBuilds,
+      allBuilds,
+      defaultBuild,
+      majorMinorOnly: true,
+      legacyTildeEquals: true
+    });
+    source = result.source;
+    selection = getPythonVersionForBuild(result.build) ?? defaultPv;
+    if (pythonPackage.manifest?.origin && !result.notAvailable && !result.invalidConstraint && !versionLessOrEqual(defaultPv, selection)) {
+      const originalVersion = pythonVersionString(selection);
+      selection = defaultPv;
+      autoUpgraded = true;
+      console.log(
+        `Python version ${originalVersion} detected in ${source} is below the minimum supported version. Using python version: ${pythonVersionString(selection)}`
+      );
+    } else if (result.notAvailable) {
+      const npv = getPythonVersionForBuild(result.notAvailable.build);
+      if (npv && isDiscontinued(npv)) {
         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.`
+          message: `Python version "${pythonVersionString(npv)}" detected in ${source} is discontinued and must be upgraded.`
         });
       }
-      if (isInstalled(requested)) {
-        selection = requested;
-        console.log(`Using Python ${selection.version} from ${source}`);
-      } else {
+      if (npv) {
         console.warn(
-          `Warning: Python version "${version2}" detected in ${source} is not installed and will be ignored. https://vercel.link/python-version`
+          `Warning: Python version "${pythonVersionString(npv)}" detected in ${source} is not installed and will be ignored. https://vercel.link/python-version`
         );
-        console.log(`Using python version: ${selection.version}`);
       }
-    } else {
+      console.log(`Using python version: ${pythonVersionString(selection)}`);
+    } else if (result.invalidConstraint) {
       console.warn(
-        `Warning: Python version "${version2}" detected in ${source} is invalid and will be ignored. https://vercel.link/python-version`
+        `Warning: Python version "${result.invalidConstraint.versionString}" detected in ${source} is invalid and will be ignored. https://vercel.link/python-version`
+      );
+      console.log(`Using python version: ${pythonVersionString(selection)}`);
+    } else {
+      console.log(
+        `Using Python ${pythonVersionString(selection)} from ${source}`
       );
-      console.log(`Using python version: ${selection.version}`);
     }
-  } 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.`
+      message: `Python version "${pythonVersionString(selection)}" 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";
+    const srcSuffix = source ? `detected in ${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`
+      `Error: Python version "${pythonVersionString(selection)}" ${srcSuffix} has reached End-of-Life. Deployments created on or after ${d} will fail to build. https://vercel.link/python-version`
     );
   }
-  return selection;
+  let pinVersionFilePath;
+  const hasPythonVersionFile = pythonPackage.configs?.some(
+    (configSet) => configSet[import_python_analysis.PythonConfigKind.PythonVersion] !== void 0
+  ) ?? false;
+  if (!hasPythonVersionFile && pythonPackage.manifest && versionLessOrEqual(selection, defaultPv)) {
+    if (autoUpgraded || !pythonPackage.manifest.origin && source?.endsWith("pyproject.toml")) {
+      const manifestDir = (0, import_path4.join)(rootDir, (0, import_path4.dirname)(pythonPackage.manifest.path));
+      pinVersionFilePath = (0, import_path4.join)(manifestDir, ".python-version");
+    }
+  }
+  return {
+    pythonVersion: selection,
+    pythonPackage,
+    versionSource: source,
+    pinVersionFilePath
+  };
 }
 function isDiscontinued({ discontinueDate }) {
   const today = Date.now();
@@ -3526,10 +3503,10 @@ function getInstalledPythons() {
   installedPythonsCache = uv.listInstalledPythons();
   return installedPythonsCache;
 }
-function isInstalled({ version: version2 }) {
+function isInstalled(pv) {
   try {
     const installed = getInstalledPythons();
-    return installed.has(version2);
+    return installed.has(pythonVersionString(pv));
   } catch (err) {
     throw new import_build_utils3.NowBuildError({
       code: "UV_ERROR",
@@ -3554,11 +3531,11 @@ async function isInstalled2(pythonPath, dependency, cwd) {
       {
         stdio: "pipe",
         cwd,
-        env: { ...process.env, PYTHONPATH: (0, import_path4.join)(cwd, resolveVendorDir()) }
+        env: { ...process.env, PYTHONPATH: (0, import_path5.join)(cwd, resolveVendorDir()) }
       }
     );
     return stdout.startsWith(cwd);
-  } catch (err) {
+  } catch (_err) {
     return false;
   }
 }
@@ -3577,11 +3554,11 @@ async function areRequirementsInstalled(pythonPath, requirementsPath, cwd) {
       {
         stdio: "pipe",
         cwd,
-        env: { ...process.env, PYTHONPATH: (0, import_path4.join)(cwd, resolveVendorDir()) }
+        env: { ...process.env, PYTHONPATH: (0, import_path5.join)(cwd, resolveVendorDir()) }
       }
     );
     return true;
-  } catch (err) {
+  } catch (_err) {
     return false;
   }
 }
@@ -3615,88 +3592,74 @@ function resolveVendorDir() {
   const vendorDir = process.env.VERCEL_PYTHON_VENDOR_DIR || "_vendor";
   return vendorDir;
 }
-function toBuildError(error) {
-  return new import_build_utils4.NowBuildError({
-    code: error.code,
-    message: error.message,
-    link: error.link,
-    action: error.action
-  });
-}
-async function detectInstallSource({
-  workPath,
-  entryDirectory,
-  repoRootPath
+async function discoverPackage({
+  entrypointDir,
+  rootDir
 }) {
-  const entrypointDir = (0, import_path4.join)(workPath, entryDirectory);
-  const rootDir = repoRootPath ?? workPath;
-  let pythonPackage;
   try {
-    pythonPackage = await (0, import_python_analysis.discoverPythonPackage)({
-      entrypointDir,
-      rootDir
-    });
+    return await (0, import_python_analysis2.discoverPythonPackage)({ entrypointDir, rootDir });
   } catch (error) {
-    if (error instanceof import_python_analysis.PythonAnalysisError) {
+    if (error instanceof import_python_analysis2.PythonAnalysisError) {
       if (error.fileContent && (error.code.endsWith("_PARSE_ERROR") || error.code.endsWith("_VALIDATION_ERROR"))) {
         console.log(
           `Failed to parse "${error.path}". File content:
 ${error.fileContent}`
         );
       }
-      throw toBuildError(error);
+      throw new import_build_utils4.NowBuildError({
+        code: error.code,
+        message: error.message,
+        link: error.link,
+        action: error.action
+      });
     }
     throw error;
   }
+}
+function detectInstallSource(pythonPackage, rootDir) {
   let manifestType = null;
   let manifestPath = null;
   const lockFile = pythonPackage.manifest?.lockFile ?? pythonPackage.workspaceLockFile;
   if (lockFile) {
-    if (lockFile.kind === import_python_analysis.PythonLockFileKind.UvLock) {
+    if (lockFile.kind === import_python_analysis2.PythonLockFileKind.UvLock) {
       manifestType = "uv.lock";
-      manifestPath = (0, import_path4.join)(rootDir, lockFile.path);
-    } else if (lockFile.kind === import_python_analysis.PythonLockFileKind.PylockToml) {
+      manifestPath = (0, import_path5.join)(rootDir, lockFile.path);
+    } else if (lockFile.kind === import_python_analysis2.PythonLockFileKind.PylockToml) {
       manifestType = "pylock.toml";
-      manifestPath = (0, import_path4.join)(rootDir, lockFile.path);
+      manifestPath = (0, import_path5.join)(rootDir, lockFile.path);
     }
   } else if (pythonPackage.manifest) {
     manifestType = "pyproject.toml";
-    manifestPath = (0, import_path4.join)(rootDir, pythonPackage.manifest.path);
+    manifestPath = (0, import_path5.join)(rootDir, pythonPackage.manifest.path);
   }
   return { manifestPath, manifestType, pythonPackage };
 }
 async function ensureUvProject({
   workPath,
-  entryDirectory,
-  repoRootPath,
+  rootDir,
+  pythonPackage,
   pythonVersion,
   uv,
   generateLockFile = false,
   requireBinaryWheels = false
 }) {
-  const rootDir = repoRootPath ?? workPath;
-  const installInfo = await detectInstallSource({
-    workPath,
-    entryDirectory,
-    repoRootPath
-  });
-  const { manifestType, pythonPackage } = installInfo;
-  const manifest = pythonPackage?.manifest;
+  const { manifestType } = detectInstallSource(pythonPackage, rootDir);
+  const manifest = pythonPackage.manifest;
   let projectDir;
   let pyprojectPath;
   let lockPath = null;
   let lockFileProvidedByUser = false;
   if (manifestType === "uv.lock" || manifestType === "pylock.toml") {
     lockFileProvidedByUser = true;
-    const lockFile = pythonPackage?.manifest?.lockFile ?? pythonPackage?.workspaceLockFile;
+    const lockFile = pythonPackage.manifest?.lockFile ?? pythonPackage.workspaceLockFile;
     if (!lockFile) {
       throw new Error(
         `Expected lock file path to be resolved, but it was null`
       );
     }
-    lockPath = (0, import_path4.join)(rootDir, lockFile.path);
-    projectDir = (0, import_path4.dirname)(lockPath);
-    pyprojectPath = (0, import_path4.join)(projectDir, "pyproject.toml");
+    lockPath = (0, import_path5.join)(rootDir, lockFile.path);
+    projectDir = (0, import_path5.dirname)(lockPath);
+    pyprojectPath = (0, import_path5.join)(projectDir, "pyproject.toml");
     if (!import_fs3.default.existsSync(pyprojectPath)) {
       throw new Error(
         `Expected "pyproject.toml" next to "${lockFile.kind}" in "${projectDir}"`
@@ -3704,14 +3667,14 @@ async function ensureUvProject({
     }
     console.log(`Installing required dependencies from ${lockFile.kind}...`);
   } else if (manifest) {
-    projectDir = (0, import_path4.join)(rootDir, (0, import_path4.dirname)(manifest.path));
-    pyprojectPath = (0, import_path4.join)(rootDir, manifest.path);
+    projectDir = (0, import_path5.join)(rootDir, (0, import_path5.dirname)(manifest.path));
+    pyprojectPath = (0, import_path5.join)(rootDir, manifest.path);
     const originKind = manifest.origin?.kind;
-    if (originKind === import_python_analysis.PythonManifestConvertedKind.Pipfile) {
+    if (originKind === import_python_analysis2.PythonManifestConvertedKind.Pipfile) {
       console.log("Installing required dependencies from Pipfile...");
-    } else if (originKind === import_python_analysis.PythonManifestConvertedKind.PipfileLock) {
+    } else if (originKind === import_python_analysis2.PythonManifestConvertedKind.PipfileLock) {
       console.log("Installing required dependencies from Pipfile.lock...");
-    } else if (originKind === import_python_analysis.PythonManifestConvertedKind.RequirementsTxt || originKind === import_python_analysis.PythonManifestConvertedKind.RequirementsIn) {
+    } else if (originKind === import_python_analysis2.PythonManifestConvertedKind.RequirementsTxt || originKind === import_python_analysis2.PythonManifestConvertedKind.RequirementsIn) {
       console.log(
         `Installing required dependencies from ${manifest.origin?.path ?? "requirements.txt"}...`
       );
@@ -3719,16 +3682,16 @@ async function ensureUvProject({
       console.log("Installing required dependencies from pyproject.toml...");
     }
     if (manifest.origin) {
-      if (manifest.data.project && !manifest.data.project["requires-python"]) {
+      if (manifest.data.project) {
         manifest.data.project["requires-python"] = `~=${pythonVersion}.0`;
       }
-      const content = (0, import_python_analysis.stringifyManifest)(manifest.data);
-      pyprojectPath = (0, import_path4.join)(projectDir, "pyproject.toml");
+      const content = (0, import_python_analysis2.stringifyManifest)(manifest.data);
+      pyprojectPath = (0, import_path5.join)(projectDir, "pyproject.toml");
       await import_fs3.default.promises.writeFile(pyprojectPath, content);
     }
-    const workspaceLockFile = pythonPackage?.workspaceLockFile;
+    const workspaceLockFile = pythonPackage.workspaceLockFile;
     if (workspaceLockFile) {
-      lockPath = (0, import_path4.join)(rootDir, workspaceLockFile.path);
+      lockPath = (0, import_path5.join)(rootDir, workspaceLockFile.path);
     } else {
       await uv.lock(
         projectDir,
@@ -3743,24 +3706,24 @@ async function ensureUvProject({
     }
   } else {
     projectDir = workPath;
-    pyprojectPath = (0, import_path4.join)(projectDir, "pyproject.toml");
+    pyprojectPath = (0, import_path5.join)(projectDir, "pyproject.toml");
     console.log(
       "No Python manifest found; creating an empty pyproject.toml and uv.lock..."
     );
     const requiresPython = `~=${pythonVersion}.0`;
-    const minimalManifest = (0, import_python_analysis.createMinimalManifest)({
+    const minimalManifest = (0, import_python_analysis2.createMinimalManifest)({
       name: "app",
       requiresPython,
       dependencies: []
     });
-    const content = (0, import_python_analysis.stringifyManifest)(minimalManifest);
+    const content = (0, import_python_analysis2.stringifyManifest)(minimalManifest);
     await import_fs3.default.promises.writeFile(pyprojectPath, content);
     await uv.lock(
       projectDir,
       requireBinaryWheels ? { noBuild: true, upgrade: true } : void 0
     );
   }
-  const resolvedLockPath = lockPath && import_fs3.default.existsSync(lockPath) ? lockPath : (0, import_path4.join)(projectDir, "uv.lock");
+  const resolvedLockPath = lockPath && import_fs3.default.existsSync(lockPath) ? lockPath : (0, import_path5.join)(projectDir, "uv.lock");
   return {
     projectDir,
     pyprojectPath,
@@ -3769,7 +3732,7 @@ async function ensureUvProject({
   };
 }
 async function pipInstall(pipPath, uvPath, workPath, args, targetDir) {
-  const target = targetDir ? (0, import_path4.join)(targetDir, resolveVendorDir()) : resolveVendorDir();
+  const target = targetDir ? (0, import_path5.join)(targetDir, resolveVendorDir()) : resolveVendorDir();
   process.env.PIP_USER = "0";
   if (uvPath) {
     const uvArgs = [
@@ -3786,7 +3749,7 @@ async function pipInstall(pipPath, uvPath, workPath, args, targetDir) {
     try {
       await (0, import_execa3.default)(uvPath, uvArgs, {
         cwd: workPath,
-        env: getProtectedUvEnv()
+        env: getProtectedUvEnv(process.env, getUvCacheDir(workPath))
       });
       return;
     } catch (err) {
@@ -3863,9 +3826,9 @@ async function installRequirementsFile({
 // src/dependency-externalizer.ts
 var import_fs4 = __toESM(require("fs"));
 var import_util = require("util");
-var import_path5 = require("path");
+var import_path6 = require("path");
 var import_build_utils5 = require("@vercel/build-utils");
-var import_python_analysis2 = require("@vercel/python-analysis");
+var import_python_analysis3 = require("@vercel/python-analysis");
 var readFile = (0, import_util.promisify)(import_fs4.default.readFile);
 var LAMBDA_SIZE_THRESHOLD_BYTES = 249 * 1024 * 1024;
 var LAMBDA_PACKING_TARGET_BYTES = 245 * 1024 * 1024;
@@ -4002,9 +3965,9 @@ To fix this, either:
     }
     let lockFile;
     try {
-      lockFile = (0, import_python_analysis2.parseUvLock)(lockContent, this.uvLockPath);
+      lockFile = (0, import_python_analysis3.parseUvLock)(lockContent, this.uvLockPath);
     } catch (error) {
-      if (error instanceof import_python_analysis2.PythonAnalysisError) {
+      if (error instanceof import_python_analysis3.PythonAnalysisError) {
         if (error.fileContent) {
           console.log(
             `Failed to parse "${error.path}". File content:
@@ -4025,7 +3988,7 @@ ${error.fileContent}`
         `Excluding project package "${this.projectName}" from runtime installation`
       );
     }
-    const classification = (0, import_python_analysis2.classifyPackages)({
+    const classification = (0, import_python_analysis3.classifyPackages)({
       lockFile,
       excludePackages
     });
@@ -4089,11 +4052,11 @@ ${error.fileContent}`
       ...bundledPublic,
       ...this.alwaysBundlePackages
     ];
-    const projectDirRel = (0, import_path5.relative)(this.workPath, this.uvProjectDir);
-    const uvLockRel = (0, import_path5.relative)(this.workPath, this.uvLockPath);
+    const projectDirRel = (0, import_path6.relative)(this.workPath, this.uvProjectDir);
+    const uvLockRel = (0, import_path6.relative)(this.workPath, this.uvLockPath);
     const isOutsideWorkPath = projectDirRel.startsWith("..") || uvLockRel.startsWith("..");
     if (isOutsideWorkPath) {
-      const srcPyproject = (0, import_path5.join)(this.uvProjectDir, "pyproject.toml");
+      const srcPyproject = (0, import_path6.join)(this.uvProjectDir, "pyproject.toml");
       files[`${UV_BUNDLE_DIR}/pyproject.toml`] = new import_build_utils5.FileFsRef({
         fsPath: srcPyproject
       });
@@ -4111,8 +4074,8 @@ ${error.fileContent}`
     if (process.env.VERCEL_BUILD_IMAGE) {
       try {
         const uvBinaryPath = await getUvBinaryForBundling(this.pythonPath);
-        const uvBundleDir = (0, import_path5.join)(this.workPath, UV_BUNDLE_DIR);
-        const uvLocalPath = (0, import_path5.join)(uvBundleDir, "uv");
+        const uvBundleDir = (0, import_path6.join)(this.workPath, UV_BUNDLE_DIR);
+        const uvLocalPath = (0, import_path6.join)(uvBundleDir, "uv");
         await import_fs4.default.promises.mkdir(uvBundleDir, { recursive: true });
         await import_fs4.default.promises.copyFile(uvBinaryPath, uvLocalPath);
         await import_fs4.default.promises.chmod(uvLocalPath, 493);
@@ -4152,30 +4115,30 @@ async function mirrorPackagesIntoVendor({
   if (includePackages && includePackages.length === 0) {
     return vendorFiles;
   }
-  const includeSet = includePackages ? new Set(includePackages.map(import_python_analysis2.normalizePackageName)) : null;
+  const includeSet = includePackages ? new Set(includePackages.map(import_python_analysis3.normalizePackageName)) : null;
   const sitePackageDirs = await getVenvSitePackagesDirs(venvPath);
   for (const dir of sitePackageDirs) {
     if (!import_fs4.default.existsSync(dir))
       continue;
-    const resolvedDir = (0, import_path5.resolve)(dir);
-    const dirPrefix = resolvedDir + import_path5.sep;
-    const distributions = await (0, import_python_analysis2.scanDistributions)(dir);
+    const resolvedDir = (0, import_path6.resolve)(dir);
+    const dirPrefix = resolvedDir + import_path6.sep;
+    const distributions = await (0, import_python_analysis3.scanDistributions)(dir);
     for (const [name, dist] of distributions) {
       if (includeSet && !includeSet.has(name))
         continue;
       for (const { path: rawPath } of dist.files) {
-        const filePath = rawPath.replaceAll("/", import_path5.sep);
-        if (!(0, import_path5.resolve)(resolvedDir, filePath).startsWith(dirPrefix)) {
+        const filePath = rawPath.replaceAll("/", import_path6.sep);
+        if (!(0, import_path6.resolve)(resolvedDir, filePath).startsWith(dirPrefix)) {
           continue;
         }
-        if (filePath.endsWith(".pyc") || filePath.split(import_path5.sep).includes("__pycache__")) {
+        if (filePath.endsWith(".pyc") || filePath.split(import_path6.sep).includes("__pycache__")) {
           continue;
         }
-        const srcFsPath = (0, import_path5.join)(dir, filePath);
+        const srcFsPath = (0, import_path6.join)(dir, filePath);
         if (!import_fs4.default.existsSync(srcFsPath)) {
           continue;
         }
-        const bundlePath = (0, import_path5.join)(vendorDirName, filePath).replace(/\\/g, "/");
+        const bundlePath = (0, import_path6.join)(vendorDirName, filePath).replace(/\\/g, "/");
         vendorFiles[bundlePath] = new import_build_utils5.FileFsRef({ fsPath: srcFsPath });
       }
     }
@@ -4226,21 +4189,21 @@ async function calculatePerPackageSizes(venvPath) {
   for (const dir of sitePackageDirs) {
     if (!import_fs4.default.existsSync(dir))
       continue;
-    const resolvedDir = (0, import_path5.resolve)(dir);
-    const dirPrefix = resolvedDir + import_path5.sep;
-    const distributions = await (0, import_python_analysis2.scanDistributions)(dir);
+    const resolvedDir = (0, import_path6.resolve)(dir);
+    const dirPrefix = resolvedDir + import_path6.sep;
+    const distributions = await (0, import_python_analysis3.scanDistributions)(dir);
     for (const [name, dist] of distributions) {
       let totalSize = 0;
       for (const { path: rawPath } of dist.files) {
-        const filePath = rawPath.replaceAll("/", import_path5.sep);
-        if (!(0, import_path5.resolve)(resolvedDir, filePath).startsWith(dirPrefix)) {
+        const filePath = rawPath.replaceAll("/", import_path6.sep);
+        if (!(0, import_path6.resolve)(resolvedDir, filePath).startsWith(dirPrefix)) {
           continue;
         }
-        if (filePath.endsWith(".pyc") || filePath.split(import_path5.sep).includes("__pycache__")) {
+        if (filePath.endsWith(".pyc") || filePath.split(import_path6.sep).includes("__pycache__")) {
           continue;
         }
         try {
-          const stats = await import_fs4.default.promises.stat((0, import_path5.join)(dir, filePath));
+          const stats = await import_fs4.default.promises.stat((0, import_path6.join)(dir, filePath));
           totalSize += stats.size;
         } catch {
         }
@@ -4251,19 +4214,17 @@ async function calculatePerPackageSizes(venvPath) {
   return sizes;
 }
 
-// src/index.ts
-var import_build_utils13 = require("@vercel/build-utils");
-
 // src/start-dev-server.ts
 var import_child_process2 = require("child_process");
-var import_fs5 = require("fs");
-var import_path7 = require("path");
+var import_fs6 = require("fs");
+var import_path8 = require("path");
 var import_build_utils8 = require("@vercel/build-utils");
 var import_get_port = __toESM(require_get_port());
 var import_is_port_reachable = __toESM(require_is_port_reachable());
 
 // src/entrypoint.ts
-var import_path6 = require("path");
+var import_fs5 = __toESM(require("fs"));
+var import_path7 = require("path");
 var import_build_utils6 = require("@vercel/build-utils");
 var import_build_utils7 = require("@vercel/build-utils");
 var PYTHON_ENTRYPOINT_FILENAMES = [
@@ -4281,12 +4242,26 @@ var PYTHON_CANDIDATE_ENTRYPOINTS = getCandidateEntrypointsInDirs(
 function getCandidateEntrypointsInDirs(dirs) {
   return dirs.flatMap(
     (dir) => PYTHON_ENTRYPOINT_FILENAMES.map(
-      (filename) => import_path6.posix.join(dir, `${filename}.py`)
+      (filename) => import_path7.posix.join(dir, `${filename}.py`)
     )
   );
 }
+async function fileExists(filePath) {
+  try {
+    const stat = await import_fs5.default.promises.stat(filePath);
+    return stat.isFile();
+  } catch {
+    return false;
+  }
+}
+async function checkEntrypoint(workPath, relPath) {
+  const absPath = (0, import_path7.join)(workPath, relPath);
+  if (!await fileExists(absPath))
+    return false;
+  return (0, import_build_utils6.isPythonEntrypoint)({ fsPath: absPath });
+}
 async function getPyprojectEntrypoint(workPath) {
-  const pyprojectData = await (0, import_build_utils7.readConfigFile)((0, import_path6.join)(workPath, "pyproject.toml"));
+  const pyprojectData = await (0, import_build_utils7.readConfigFile)((0, import_path7.join)(workPath, "pyproject.toml"));
   if (!pyprojectData)
     return null;
   const scripts = pyprojectData.project?.scripts;
@@ -4298,46 +4273,56 @@ async function getPyprojectEntrypoint(workPath) {
     return null;
   const modulePath = match[1];
   const relPath = modulePath.replace(/\./g, "/");
-  try {
-    const fsFiles = await (0, import_build_utils6.glob)("**", workPath);
-    const candidates = [`${relPath}.py`, `${relPath}/__init__.py`];
-    for (const candidate of candidates) {
-      if (fsFiles[candidate])
-        return candidate;
-    }
-    return null;
-  } catch {
-    (0, import_build_utils6.debug)("Failed to discover Python entrypoint from pyproject.toml");
-    return null;
+  const candidates = [`${relPath}.py`, `${relPath}/__init__.py`];
+  for (const candidate of candidates) {
+    if (await fileExists((0, import_path7.join)(workPath, candidate)))
+      return candidate;
   }
+  return null;
 }
-async function findValidEntrypoint(fsFiles, candidates) {
+async function findValidEntrypoint(workPath, candidates) {
   for (const candidate of candidates) {
-    if (fsFiles[candidate]) {
-      const isValid = await (0, import_build_utils6.isPythonEntrypoint)(fsFiles[candidate]);
-      if (isValid) {
-        (0, import_build_utils6.debug)(`Detected Python entrypoint: ${candidate}`);
-        return candidate;
-      }
+    if (await checkEntrypoint(workPath, candidate)) {
+      (0, import_build_utils6.debug)(`Detected Python entrypoint: ${candidate}`);
+      return candidate;
     }
   }
   return null;
 }
+async function checkDjangoManage(workPath) {
+  const managePath = (0, import_path7.join)(workPath, "manage.py");
+  try {
+    const content = await import_fs5.default.promises.readFile(managePath, "utf-8");
+    if (!content.includes("DJANGO_SETTINGS_MODULE"))
+      return false;
+    (0, import_build_utils6.debug)(`Found Django manage.py with DJANGO_SETTINGS_MODULE at ${workPath}`);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function getSubdirectories(workPath) {
+  try {
+    const entries = await import_fs5.default.promises.readdir(workPath, {
+      withFileTypes: true
+    });
+    return entries.filter((e) => e.isDirectory() && !e.name.startsWith(".")).map((e) => e.name).sort();
+  } catch {
+    return [];
+  }
+}
 async function detectGenericPythonEntrypoint(workPath, configuredEntrypoint) {
   const entry = configuredEntrypoint.endsWith(".py") ? configuredEntrypoint : `${configuredEntrypoint}.py`;
   try {
-    const fsFiles = await (0, import_build_utils6.glob)("**", workPath);
-    if (fsFiles[entry]) {
-      const isValid = await (0, import_build_utils6.isPythonEntrypoint)(fsFiles[entry]);
-      if (isValid) {
-        (0, import_build_utils6.debug)(`Using configured Python entrypoint: ${entry}`);
-        return entry;
-      }
+    if (await checkEntrypoint(workPath, entry)) {
+      (0, import_build_utils6.debug)(`Using configured Python entrypoint: ${entry}`);
+      return { entrypoint: entry };
     }
-    const candidates = PYTHON_CANDIDATE_ENTRYPOINTS.filter(
-      (c) => !!fsFiles[c]
+    const found = await findValidEntrypoint(
+      workPath,
+      PYTHON_CANDIDATE_ENTRYPOINTS
     );
-    return findValidEntrypoint(fsFiles, candidates);
+    return found ? { entrypoint: found } : null;
   } catch {
     (0, import_build_utils6.debug)("Failed to discover Python entrypoint");
     return null;
@@ -4346,52 +4331,37 @@ async function detectGenericPythonEntrypoint(workPath, configuredEntrypoint) {
 async function detectDjangoPythonEntrypoint(workPath, configuredEntrypoint) {
   const entry = configuredEntrypoint.endsWith(".py") ? configuredEntrypoint : `${configuredEntrypoint}.py`;
   try {
-    const fsFiles = await (0, import_build_utils6.glob)("**", workPath);
-    if (fsFiles[entry]) {
-      const isValid = await (0, import_build_utils6.isPythonEntrypoint)(fsFiles[entry]);
-      if (isValid) {
-        (0, import_build_utils6.debug)(`Using configured Python entrypoint: ${entry}`);
-        return entry;
-      }
+    if (await checkEntrypoint(workPath, entry)) {
+      (0, import_build_utils6.debug)(`Using configured Python entrypoint: ${entry}`);
+      return { entrypoint: entry };
     }
-    const rootGlobs = await (0, import_build_utils6.glob)("*", {
-      cwd: workPath,
-      includeDirectories: true
-    });
-    const rootDirs = [
-      "",
-      ...Object.keys(rootGlobs).filter(
-        (name) => !name.startsWith(".") && rootGlobs[name].mode != null && (0, import_build_utils6.isDirectory)(rootGlobs[name].mode)
-      )
-    ];
+    const subdirs = await getSubdirectories(workPath);
+    const rootDirs = ["", ...subdirs];
     for (const rootDir of rootDirs) {
-      const currPath = (0, import_path6.join)(workPath, rootDir);
-      const wsgiEntry = await (0, import_build_utils6.getDjangoEntrypoint)(currPath);
-      if (wsgiEntry) {
-        const fullWsgiEntry = import_path6.posix.join(rootDir, wsgiEntry);
-        if (fsFiles[fullWsgiEntry]) {
-          (0, import_build_utils6.debug)(`Using Django WSGI entrypoint: ${fullWsgiEntry}`);
-          return fullWsgiEntry;
-        }
+      const currPath = (0, import_path7.join)(workPath, rootDir);
+      const isDjango = await checkDjangoManage(currPath);
+      if (isDjango) {
+        return { baseDir: rootDir };
       }
     }
-    const baseCandidates = getCandidateEntrypointsInDirs(rootDirs);
-    const candidates = baseCandidates.filter((c) => !!fsFiles[c]);
-    return findValidEntrypoint(fsFiles, candidates);
+    const candidates = getCandidateEntrypointsInDirs(rootDirs);
+    const found = await findValidEntrypoint(workPath, candidates);
+    return found ? { entrypoint: found } : null;
   } catch {
     (0, import_build_utils6.debug)("Failed to discover Django Python entrypoint");
     return null;
   }
 }
 async function detectPythonEntrypoint(framework, workPath, configuredEntrypoint) {
-  const entrypoint = framework === "django" ? await detectDjangoPythonEntrypoint(workPath, configuredEntrypoint) : await detectGenericPythonEntrypoint(workPath, configuredEntrypoint);
-  if (entrypoint)
-    return entrypoint;
-  return await getPyprojectEntrypoint(workPath);
+  const result = framework === "django" ? await detectDjangoPythonEntrypoint(workPath, configuredEntrypoint) : await detectGenericPythonEntrypoint(workPath, configuredEntrypoint);
+  if (result)
+    return result;
+  const pyprojectEntry = await getPyprojectEntrypoint(workPath);
+  return pyprojectEntry ? { entrypoint: pyprojectEntry } : null;
 }
 
 // src/start-dev-server.ts
-var import_python_analysis3 = require("@vercel/python-analysis");
+var import_python_analysis4 = require("@vercel/python-analysis");
 var DEV_SERVER_STARTUP_TIMEOUT = 1e4;
 function silenceNodeWarnings() {
   const original = process.emitWarning.bind(
@@ -4464,22 +4434,24 @@ async function syncDependencies({
   onStdout,
   onStderr
 }) {
-  const installInfo = await detectInstallSource({
-    workPath,
-    entryDirectory: "."
+  const pythonPackage = await discoverPackage({
+    entrypointDir: workPath,
+    rootDir: workPath
   });
-  let { manifestType, manifestPath } = installInfo;
-  const manifest = installInfo.pythonPackage?.manifest;
+  const installInfo = detectInstallSource(pythonPackage, workPath);
+  const { manifestType } = installInfo;
+  let { manifestPath } = installInfo;
+  const manifest = pythonPackage.manifest;
   if (!manifestType || !manifestPath) {
     (0, import_build_utils8.debug)("No Python project manifest found, skipping dependency sync");
     return;
   }
   if (manifest?.origin && manifestType === "pyproject.toml") {
-    const syncDir = (0, import_path7.join)(workPath, ".vercel", "python", "sync");
-    (0, import_fs5.mkdirSync)(syncDir, { recursive: true });
-    const tempPyproject = (0, import_path7.join)(syncDir, "pyproject.toml");
-    const content = (0, import_python_analysis3.stringifyManifest)(manifest.data);
-    (0, import_fs5.writeFileSync)(tempPyproject, content, "utf8");
+    const syncDir = (0, import_path8.join)(workPath, ".vercel", "python", "sync");
+    (0, import_fs6.mkdirSync)(syncDir, { recursive: true });
+    const tempPyproject = (0, import_path8.join)(syncDir, "pyproject.toml");
+    const content = (0, import_python_analysis4.stringifyManifest)(manifest.data);
+    (0, import_fs6.writeFileSync)(tempPyproject, content, "utf8");
     manifestPath = tempPyproject;
     (0, import_build_utils8.debug)(
       `Wrote converted ${manifest.origin.kind} manifest to ${tempPyproject}`
@@ -4529,7 +4501,7 @@ async function runSync({
   onStdout,
   onStderr
 }) {
-  const projectDir = (0, import_path7.dirname)(manifestPath);
+  const projectDir = (0, import_path8.dirname)(manifestPath);
   const pip = uvPath ? { cmd: uvPath, prefix: ["pip", "install"] } : { cmd: pythonBin, prefix: ["-m", "pip", "install"] };
   let spawnCmd;
   let spawnArgs;
@@ -4639,21 +4611,26 @@ function installGlobalCleanupHandlers() {
 }
 function createDevShim(workPath, entry, modulePath) {
   try {
-    const vercelPythonDir = (0, import_path7.join)(workPath, ".vercel", "python");
-    (0, import_fs5.mkdirSync)(vercelPythonDir, { recursive: true });
+    const vercelPythonDir = (0, import_path8.join)(workPath, ".vercel", "python");
+    (0, import_fs6.mkdirSync)(vercelPythonDir, { recursive: true });
     let qualifiedModule = modulePath;
     let extraPythonPath;
-    if ((0, import_fs5.existsSync)((0, import_path7.join)(workPath, "__init__.py"))) {
-      const pkgName = (0, import_path7.basename)(workPath);
+    if ((0, import_fs6.existsSync)((0, import_path8.join)(workPath, "__init__.py"))) {
+      const pkgName = (0, import_path8.basename)(workPath);
       qualifiedModule = `${pkgName}.${modulePath}`;
-      extraPythonPath = (0, import_path7.dirname)(workPath);
-    }
-    const entryAbs = (0, import_path7.join)(workPath, entry);
-    const shimPath = (0, import_path7.join)(vercelPythonDir, `${DEV_SHIM_MODULE}.py`);
-    const templatePath = (0, import_path7.join)(__dirname, "..", `${DEV_SHIM_MODULE}.py`);
-    const template = (0, import_fs5.readFileSync)(templatePath, "utf8");
+      extraPythonPath = (0, import_path8.dirname)(workPath);
+    }
+    const entryAbs = (0, import_path8.join)(workPath, entry);
+    const shimPath = (0, import_path8.join)(vercelPythonDir, `${DEV_SHIM_MODULE}.py`);
+    const templatePath = (0, import_path8.join)(
+      __dirname,
+      "..",
+      "templates",
+      `${DEV_SHIM_MODULE}.py`
+    );
+    const template = (0, import_fs6.readFileSync)(templatePath, "utf8");
     const shimSource = template.replace(/__VC_DEV_MODULE_NAME__/g, qualifiedModule).replace(/__VC_DEV_ENTRY_ABS__/g, entryAbs);
-    (0, import_fs5.writeFileSync)(shimPath, shimSource, "utf8");
+    (0, import_fs6.writeFileSync)(shimPath, shimSource, "utf8");
     (0, import_build_utils8.debug)(`Prepared Python dev shim at ${shimPath}`);
     return { module: DEV_SHIM_MODULE, extraPythonPath };
   } catch (err) {
@@ -4667,13 +4644,18 @@ async function getMultiServicePythonRunner(workPath, env, systemPython, uvPath)
     (0, import_build_utils8.debug)(`Using existing virtualenv at ${venvRoot} for multi-service dev`);
     return { command: pythonCmd, args: [] };
   }
-  const venvPath = (0, import_path7.join)(workPath, ".venv");
-  await ensureVenv({ pythonPath: systemPython, venvPath, uvPath, quiet: true });
+  const venvPath = (0, import_path8.join)(workPath, ".venv");
+  await ensureVenv({
+    pythonPath: systemPython,
+    venvPath,
+    uvPath,
+    quiet: true
+  });
   (0, import_build_utils8.debug)(`Created virtualenv at ${venvPath} for multi-service dev`);
   const pythonBin = getVenvPythonBin(venvPath);
   const binDir = getVenvBinDir(venvPath);
   env.VIRTUAL_ENV = venvPath;
-  env.PATH = `${binDir}${import_path7.delimiter}${env.PATH || ""}`;
+  env.PATH = `${binDir}${import_path8.delimiter}${env.PATH || ""}`;
   return { command: pythonBin, args: [] };
 }
 var startDevServer = async (opts) => {
@@ -4686,29 +4668,7 @@ var startDevServer = async (opts) => {
     onStderr
   } = opts;
   const framework = config?.framework;
-  if (!framework) {
-    return null;
-  }
-  if (!restoreWarnings)
-    restoreWarnings = silenceNodeWarnings();
-  installGlobalCleanupHandlers();
-  const entry = await detectPythonEntrypoint(
-    framework,
-    workPath,
-    rawEntrypoint
-  );
-  if (!entry) {
-    const searched = PYTHON_CANDIDATE_ENTRYPOINTS.join(", ");
-    throw new import_build_utils8.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`,
-      action: "Learn More"
-    });
-  }
-  const modulePath = entry.replace(/\.py$/i, "").replace(/[\\/]/g, ".");
-  const env = { ...process.env, ...meta.env || {} };
-  const serverKey = `${workPath}::${entry}::${framework}`;
+  const serverKey = `${workPath}::${framework}`;
   const existing = PERSISTENT_SERVERS.get(serverKey);
   if (existing) {
     return {
@@ -4730,6 +4690,38 @@ var startDevServer = async (opts) => {
       };
     }
   }
+  if (!framework) {
+    return null;
+  }
+  if (!restoreWarnings)
+    restoreWarnings = silenceNodeWarnings();
+  installGlobalCleanupHandlers();
+  const detected = await detectPythonEntrypoint(
+    framework,
+    workPath,
+    rawEntrypoint
+  );
+  const env = { ...process.env, ...meta.env || {} };
+  let entry = detected?.entrypoint;
+  if (!entry) {
+    const hookResult = await runFrameworkHook(framework, {
+      pythonEnv: env,
+      projectDir: (0, import_path8.join)(workPath, detected?.baseDir ?? ""),
+      entrypoint: rawEntrypoint,
+      detected: detected ?? void 0
+    });
+    entry = hookResult?.entrypoint;
+  }
+  if (!entry) {
+    const searched = PYTHON_CANDIDATE_ENTRYPOINTS.join(", ");
+    throw new import_build_utils8.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`,
+      action: "Learn More"
+    });
+  }
+  const modulePath = entry.replace(/\.py$/i, "").replace(/[\\/]/g, ".");
   let childProcess = null;
   let stdoutLogListener = null;
   let stderrLogListener = null;
@@ -4821,7 +4813,7 @@ If you are using a virtual environment, activate it before running "vercel dev",
     env.PORT = `${port}`;
     const devShim = createDevShim(workPath, entry, modulePath);
     if (devShim) {
-      const vercelPythonDir = (0, import_path7.join)(workPath, ".vercel", "python");
+      const vercelPythonDir = (0, import_path8.join)(workPath, ".vercel", "python");
       const pathParts = [vercelPythonDir];
       if (devShim.extraPythonPath) {
         pathParts.push(devShim.extraPythonPath);
@@ -4830,7 +4822,7 @@ If you are using a virtual environment, activate it before running "vercel dev",
       if (existingPythonPath) {
         pathParts.push(existingPythonPath);
       }
-      env.PYTHONPATH = pathParts.join(import_path7.delimiter);
+      env.PYTHONPATH = pathParts.join(import_path8.delimiter);
     }
     const moduleToRun = devShim?.module || modulePath;
     const pythonArgs = ["-u", "-m", moduleToRun];
@@ -4890,7 +4882,7 @@ If you are using a virtual environment, activate it before running "vercel dev",
 
 // src/quirks/index.ts
 var import_build_utils11 = require("@vercel/build-utils");
-var import_python_analysis5 = require("@vercel/python-analysis");
+var import_python_analysis6 = require("@vercel/python-analysis");
 
 // src/quirks/matplotlib.ts
 var matplotlibQuirk = {
@@ -4903,8 +4895,8 @@ var matplotlibQuirk = {
 };
 
 // src/quirks/litellm.ts
-var import_fs6 = __toESM(require("fs"));
-var import_path8 = require("path");
+var import_fs7 = __toESM(require("fs"));
+var import_path9 = require("path");
 var import_build_utils9 = require("@vercel/build-utils");
 var LAMBDA_ROOT = "/var/task";
 var CONFIG_CANDIDATES = [
@@ -4915,9 +4907,9 @@ var CONFIG_CANDIDATES = [
 ];
 async function findConfigFile(workPath) {
   for (const name of CONFIG_CANDIDATES) {
-    const candidate = (0, import_path8.join)(workPath, name);
+    const candidate = (0, import_path9.join)(workPath, name);
     try {
-      await import_fs6.default.promises.access(candidate);
+      await import_fs7.default.promises.access(candidate);
       return name;
     } catch {
     }
@@ -4932,14 +4924,14 @@ var litellmQuirk = {
     const env = {};
     const sitePackagesDirs = await getVenvSitePackagesDirs(ctx.venvPath);
     for (const sitePackages of sitePackagesDirs) {
-      const schemaPath = (0, import_path8.join)(
+      const schemaPath = (0, import_path9.join)(
         sitePackages,
         "litellm",
         "proxy",
         "schema.prisma"
       );
       try {
-        await import_fs6.default.promises.access(schemaPath);
+        await import_fs7.default.promises.access(schemaPath);
         (0, import_build_utils9.debug)(`LiteLLM quirk: found schema at ${schemaPath}`);
         buildEnv.PRISMA_SCHEMA_PATH = schemaPath;
         break;
@@ -4953,8 +4945,8 @@ var litellmQuirk = {
       const configName = await findConfigFile(ctx.workPath);
       if (configName) {
         (0, import_build_utils9.debug)(`LiteLLM quirk: found config at ${configName}`);
-        buildEnv.CONFIG_FILE_PATH = (0, import_path8.join)(ctx.workPath, configName);
-        env.CONFIG_FILE_PATH = (0, import_path8.join)(LAMBDA_ROOT, configName);
+        buildEnv.CONFIG_FILE_PATH = (0, import_path9.join)(ctx.workPath, configName);
+        env.CONFIG_FILE_PATH = (0, import_path9.join)(LAMBDA_ROOT, configName);
       }
     } else {
       (0, import_build_utils9.debug)(
@@ -4966,11 +4958,11 @@ var litellmQuirk = {
 };
 
 // src/quirks/prisma.ts
-var import_fs7 = __toESM(require("fs"));
-var import_path9 = require("path");
+var import_fs8 = __toESM(require("fs"));
+var import_path10 = require("path");
 var import_execa4 = __toESM(require_execa());
 var import_build_utils10 = require("@vercel/build-utils");
-var import_python_analysis4 = require("@vercel/python-analysis");
+var import_python_analysis5 = require("@vercel/python-analysis");
 function execErrorMessage(err) {
   if (err != null && typeof err === "object" && "stderr" in err) {
     const stderr = String(err.stderr);
@@ -5006,9 +4998,9 @@ model DummyModel {
 async function findUserSchema(workPath) {
   const envPath = process.env.PRISMA_SCHEMA_PATH;
   if (envPath) {
-    const resolved = (0, import_path9.isAbsolute)(envPath) ? envPath : (0, import_path9.join)(workPath, envPath);
+    const resolved = (0, import_path10.isAbsolute)(envPath) ? envPath : (0, import_path10.join)(workPath, envPath);
     try {
-      await import_fs7.default.promises.access(resolved);
+      await import_fs8.default.promises.access(resolved);
       return resolved;
     } catch {
       (0, import_build_utils10.debug)(`PRISMA_SCHEMA_PATH=${envPath} not found at ${resolved}`);
@@ -5016,12 +5008,12 @@ async function findUserSchema(workPath) {
     }
   }
   const candidates = [
-    (0, import_path9.join)(workPath, "schema.prisma"),
-    (0, import_path9.join)(workPath, "prisma", "schema.prisma")
+    (0, import_path10.join)(workPath, "schema.prisma"),
+    (0, import_path10.join)(workPath, "prisma", "schema.prisma")
   ];
   for (const candidate of candidates) {
     try {
-      await import_fs7.default.promises.access(candidate);
+      await import_fs8.default.promises.access(candidate);
       return candidate;
     } catch {
     }
@@ -5032,32 +5024,32 @@ async function collectFiles(dir, base) {
   const result = [];
   let entries;
   try {
-    entries = await import_fs7.default.promises.readdir(dir, { withFileTypes: true });
+    entries = await import_fs8.default.promises.readdir(dir, { withFileTypes: true });
   } catch {
     return result;
   }
   for (const entry of entries) {
     if (entry.name === "__pycache__")
       continue;
-    const full = (0, import_path9.join)(dir, entry.name);
+    const full = (0, import_path10.join)(dir, entry.name);
     if (entry.isDirectory()) {
       result.push(...await collectFiles(full, base));
     } else {
-      result.push((0, import_path9.relative)(base, full));
+      result.push((0, import_path10.relative)(base, full));
     }
   }
   return result;
 }
 async function cleanCacheArtifacts(cacheDir, extras = []) {
   const paths = [
-    (0, import_path9.join)(cacheDir, "node_modules"),
-    (0, import_path9.join)(cacheDir, "package.json"),
-    (0, import_path9.join)(cacheDir, "package-lock.json"),
+    (0, import_path10.join)(cacheDir, "node_modules"),
+    (0, import_path10.join)(cacheDir, "package.json"),
+    (0, import_path10.join)(cacheDir, "package-lock.json"),
     ...extras
   ];
   for (const p of paths) {
     try {
-      await import_fs7.default.promises.rm(p, { recursive: true, force: true });
+      await import_fs8.default.promises.rm(p, { recursive: true, force: true });
     } catch (err) {
       console.warn(
         `could not clean up ${p}: ${err instanceof Error ? err.message : String(err)}`
@@ -5081,7 +5073,7 @@ var prismaQuirk = {
   async run(ctx) {
     const { venvPath, pythonEnv, workPath } = ctx;
     const pythonPath = getVenvPythonBin(venvPath);
-    const runtimeCacheDir = (0, import_path9.join)(
+    const runtimeCacheDir = (0, import_path10.join)(
       LAMBDA_ROOT2,
       resolveVendorDir(),
       "prisma",
@@ -5091,7 +5083,7 @@ var prismaQuirk = {
     let sitePackages;
     for (const dir of sitePackagesDirs) {
       try {
-        await import_fs7.default.promises.access((0, import_path9.join)(dir, "prisma"));
+        await import_fs8.default.promises.access((0, import_path10.join)(dir, "prisma"));
         sitePackages = dir;
         break;
       } catch {
@@ -5103,15 +5095,15 @@ var prismaQuirk = {
       );
       return {};
     }
-    const cacheDir = (0, import_path9.join)(sitePackages, "prisma", "__bincache__");
-    await import_fs7.default.promises.mkdir(cacheDir, { recursive: true });
+    const cacheDir = (0, import_path10.join)(sitePackages, "prisma", "__bincache__");
+    await import_fs8.default.promises.mkdir(cacheDir, { recursive: true });
     const generateEnv = {
       ...pythonEnv,
       PRISMA_BINARY_CACHE_DIR: cacheDir
     };
-    const generatedDir = (0, import_path9.join)(workPath, "_prisma_generated");
-    const dummySchemaPath = (0, import_path9.join)(workPath, DUMMY_SCHEMA_NAME);
-    await import_fs7.default.promises.writeFile(
+    const generatedDir = (0, import_path10.join)(workPath, "_prisma_generated");
+    const dummySchemaPath = (0, import_path10.join)(workPath, DUMMY_SCHEMA_NAME);
+    await import_fs8.default.promises.writeFile(
       dummySchemaPath,
       buildDummySchema(generatedDir)
     );
@@ -5139,21 +5131,21 @@ var prismaQuirk = {
     }
     const srcBinaryPrefix = `query-engine-${getLambdaBinaryTarget()}`;
     const runtimeName = `prisma-query-engine-rhel-openssl-${RUNTIME_OPENSSL_VERSION}.x`;
-    const nodeModulesDir = (0, import_path9.join)(cacheDir, "node_modules", "prisma");
+    const nodeModulesDir = (0, import_path10.join)(cacheDir, "node_modules", "prisma");
     let engineCopied = false;
     try {
-      const entries = await import_fs7.default.promises.readdir(nodeModulesDir);
+      const entries = await import_fs8.default.promises.readdir(nodeModulesDir);
       for (const entry of entries) {
         if (!entry.startsWith(srcBinaryPrefix))
           continue;
-        const srcPath = (0, import_path9.join)(nodeModulesDir, entry);
-        const destPath = (0, import_path9.join)(cacheDir, runtimeName);
+        const srcPath = (0, import_path10.join)(nodeModulesDir, entry);
+        const destPath = (0, import_path10.join)(cacheDir, runtimeName);
         try {
-          await import_fs7.default.promises.access(destPath);
+          await import_fs8.default.promises.access(destPath);
           (0, import_build_utils10.debug)(`Engine binary: ${runtimeName} already exists, skipping`);
         } catch {
           (0, import_build_utils10.debug)(`Engine binary: copying ${entry} -> ${runtimeName}`);
-          await import_fs7.default.promises.copyFile(srcPath, destPath);
+          await import_fs8.default.promises.copyFile(srcPath, destPath);
         }
         engineCopied = true;
       }
@@ -5170,16 +5162,16 @@ var prismaQuirk = {
         message: `could not find engine binary matching "${srcBinaryPrefix}*" in "${nodeModulesDir}". This may indicate an incompatible prisma version or an unsupported platform (${process.arch}).`
       });
     }
-    const shimPath = (0, import_path9.join)(cacheDir, "openssl");
-    await import_fs7.default.promises.writeFile(
+    const shimPath = (0, import_path10.join)(cacheDir, "openssl");
+    await import_fs8.default.promises.writeFile(
       shimPath,
       `#!/bin/sh
 echo "OpenSSL ${RUNTIME_OPENSSL_VERSION}.0 1 Jan 2024 (Library: OpenSSL ${RUNTIME_OPENSSL_VERSION}.0)"
 `
     );
-    await import_fs7.default.promises.chmod(shimPath, 493);
+    await import_fs8.default.promises.chmod(shimPath, 493);
     for (const p of [generatedDir, dummySchemaPath]) {
-      await import_fs7.default.promises.rm(p, { recursive: true, force: true });
+      await import_fs8.default.promises.rm(p, { recursive: true, force: true });
     }
     await cleanCacheArtifacts(cacheDir);
     const generateMode = (process.env.VERCEL_PRISMA_GENERATE_CLIENT ?? "auto").toLowerCase();
@@ -5226,10 +5218,10 @@ echo "OpenSSL ${RUNTIME_OPENSSL_VERSION}.0 1 Jan 2024 (Library: OpenSSL ${RUNTIM
     }
     try {
       const allFiles = await collectFiles(
-        (0, import_path9.join)(sitePackages, "prisma"),
+        (0, import_path10.join)(sitePackages, "prisma"),
         sitePackages
       );
-      const count = await (0, import_python_analysis4.extendDistRecord)(sitePackages, "prisma", allFiles);
+      const count = await (0, import_python_analysis5.extendDistRecord)(sitePackages, "prisma", allFiles);
       if (count > 0) {
         (0, import_build_utils10.debug)(`Appended ${count} entries to prisma RECORD`);
       }
@@ -5254,7 +5246,7 @@ var quirks = [litellmQuirk, prismaQuirk, matplotlibQuirk];
 function toposortQuirks(activated) {
   const nameToQuirk = /* @__PURE__ */ new Map();
   for (const q of activated) {
-    nameToQuirk.set((0, import_python_analysis5.normalizePackageName)(q.dependency), q);
+    nameToQuirk.set((0, import_python_analysis6.normalizePackageName)(q.dependency), q);
   }
   const adj = /* @__PURE__ */ new Map();
   const inDegree = /* @__PURE__ */ new Map();
@@ -5265,7 +5257,7 @@ function toposortQuirks(activated) {
   for (const q of activated) {
     if (q.runsBefore) {
       for (const dep of q.runsBefore) {
-        const target = nameToQuirk.get((0, import_python_analysis5.normalizePackageName)(dep));
+        const target = nameToQuirk.get((0, import_python_analysis6.normalizePackageName)(dep));
         if (target) {
           adj.get(q).add(target);
           inDegree.set(target, inDegree.get(target) + 1);
@@ -5274,7 +5266,7 @@ function toposortQuirks(activated) {
     }
     if (q.runsAfter) {
       for (const dep of q.runsAfter) {
-        const source = nameToQuirk.get((0, import_python_analysis5.normalizePackageName)(dep));
+        const source = nameToQuirk.get((0, import_python_analysis6.normalizePackageName)(dep));
         if (source) {
           adj.get(source).add(q);
           inDegree.set(q, inDegree.get(q) + 1);
@@ -5315,14 +5307,14 @@ async function runQuirks(ctx) {
   const installedNames = /* @__PURE__ */ new Set();
   const sitePackageDirs = await getVenvSitePackagesDirs(ctx.venvPath);
   for (const dir of sitePackageDirs) {
-    const distributions = await (0, import_python_analysis5.scanDistributions)(dir);
+    const distributions = await (0, import_python_analysis6.scanDistributions)(dir);
     for (const name of distributions.keys()) {
-      installedNames.add((0, import_python_analysis5.normalizePackageName)(name));
+      installedNames.add((0, import_python_analysis6.normalizePackageName)(name));
     }
   }
   const activated = quirks.filter((quirk) => {
     const installed = installedNames.has(
-      (0, import_python_analysis5.normalizePackageName)(quirk.dependency)
+      (0, import_python_analysis6.normalizePackageName)(quirk.dependency)
     );
     if (!installed) {
       (0, import_build_utils11.debug)(`Quirk "${quirk.dependency}": not installed, skipping`);
@@ -5351,23 +5343,74 @@ async function runQuirks(ctx) {
   };
 }
 
+// src/django.ts
+var import_fs9 = require("fs");
+var import_path11 = require("path");
+var import_execa5 = __toESM(require_execa());
+var import_build_utils12 = require("@vercel/build-utils");
+var scriptPath = (0, import_path11.join)(__dirname, "..", "templates", "vc_django_settings.py");
+var script = (0, import_fs9.readFileSync)(scriptPath, "utf-8");
+async function getDjangoSettings(projectDir, env) {
+  try {
+    const { stdout } = await (0, import_execa5.default)("python", ["-c", script], {
+      env,
+      cwd: projectDir
+    });
+    return JSON.parse(stdout);
+  } catch (err) {
+    (0, import_build_utils12.debug)(`Django hook: failed to discover settings from manage.py: ${err}`);
+    return null;
+  }
+}
+
 // src/index.ts
-var readFile2 = (0, import_util2.promisify)(import_fs8.default.readFile);
-var writeFile = (0, import_util2.promisify)(import_fs8.default.writeFile);
+var import_python_analysis7 = require("@vercel/python-analysis");
+var writeFile = import_fs10.default.promises.writeFile;
 var version = 3;
+async function runFrameworkHook(framework, ctx) {
+  const hook = framework ? frameworkHooks[framework] : void 0;
+  return hook?.(ctx);
+}
+var frameworkHooks = {
+  django: async ({ pythonEnv, projectDir, detected }) => {
+    if (detected?.baseDir === void 0) {
+      (0, import_build_utils13.debug)("Django hook: no manage.py detected, skipping");
+      return;
+    }
+    const settings = await getDjangoSettings(projectDir, pythonEnv);
+    (0, import_build_utils13.debug)(`Django settings: ${JSON.stringify(settings)}`);
+    if (!settings)
+      return;
+    const baseDir = detected?.baseDir ?? "";
+    const asgiApp = settings["ASGI_APPLICATION"];
+    if (typeof asgiApp === "string") {
+      const rel = `${asgiApp.split(".").slice(0, -1).join("/")}.py`;
+      const entrypoint = baseDir ? `${baseDir}/${rel}` : rel;
+      (0, import_build_utils13.debug)(`Django hook: ASGI entrypoint: ${entrypoint}`);
+      return { entrypoint };
+    }
+    const wsgiApp = settings["WSGI_APPLICATION"];
+    if (typeof wsgiApp === "string") {
+      const rel = `${wsgiApp.split(".").slice(0, -1).join("/")}.py`;
+      const entrypoint = baseDir ? `${baseDir}/${rel}` : rel;
+      (0, import_build_utils13.debug)(`Django hook: WSGI entrypoint: ${entrypoint}`);
+      return { entrypoint };
+    }
+  }
+};
 async function downloadFilesInWorkPath({
   entrypoint,
   workPath,
   files,
   meta = {}
 }) {
-  (0, import_build_utils12.debug)("Downloading user files...");
-  let downloadedFiles = await (0, import_build_utils12.download)(files, workPath, meta);
+  (0, import_build_utils13.debug)("Downloading user files...");
+  let downloadedFiles = await (0, import_build_utils13.download)(files, workPath, meta);
   if (meta.isDev) {
-    const { devCacheDir = (0, import_path10.join)(workPath, ".now", "cache") } = meta;
-    const destCache = (0, import_path10.join)(devCacheDir, (0, import_path10.basename)(entrypoint, ".py"));
-    await (0, import_build_utils12.download)(downloadedFiles, destCache);
-    downloadedFiles = await (0, import_build_utils12.glob)("**", destCache);
+    const { devCacheDir = (0, import_path12.join)(workPath, ".now", "cache") } = meta;
+    const destCache = (0, import_path12.join)(devCacheDir, (0, import_path12.basename)(entrypoint, ".py"));
+    await (0, import_build_utils13.download)(downloadedFiles, destCache);
+    downloadedFiles = await (0, import_build_utils13.glob)("**", destCache);
     workPath = destCache;
   }
   return workPath;
@@ -5381,13 +5424,13 @@ var build = async ({
   config,
   span: parentSpan
 }) => {
-  const builderSpan = parentSpan ?? new import_build_utils12.Span({ name: "vc.builder" });
+  const builderSpan = parentSpan ?? new import_build_utils13.Span({ name: "vc.builder" });
   const framework = config?.framework;
   const shouldInstallVercelWorkers = config?.hasWorkerServices === true;
   let spawnEnv;
   let projectInstallCommand;
   let hasCustomCommand = false;
-  (0, import_build_utils12.debug)(`workPath: ${workPath}`);
+  (0, import_build_utils13.debug)(`workPath: ${workPath}`);
   workPath = await downloadFilesInWorkPath({
     workPath,
     files: originalFiles,
@@ -5396,28 +5439,31 @@ var build = async ({
   });
   try {
     if (meta.isDev) {
-      const setupCfg = (0, import_path10.join)(workPath, "setup.cfg");
+      const setupCfg = (0, import_path12.join)(workPath, "setup.cfg");
       await writeFile(setupCfg, "[install]\nprefix=\n");
     }
   } catch (err) {
     console.log('Failed to create "setup.cfg" file');
     throw err;
   }
-  let fsFiles = await (0, import_build_utils12.glob)("**", workPath);
-  if ((0, import_build_utils12.isPythonFramework)(framework) && (!fsFiles[entrypoint] || !entrypoint.endsWith(".py"))) {
-    const detected = await detectPythonEntrypoint(
+  let fsFiles = await (0, import_build_utils13.glob)("**", workPath);
+  let detected;
+  let entrypointNotFound;
+  if ((0, import_build_utils13.isPythonFramework)(framework) && // XXX: we might want to detect anyway for django!
+  (!fsFiles[entrypoint] || !entrypoint.endsWith(".py"))) {
+    detected = await detectPythonEntrypoint(
       config.framework,
       workPath,
       entrypoint
-    );
-    if (detected) {
-      (0, import_build_utils12.debug)(
-        `Resolved Python entrypoint to "${detected}" (configured "${entrypoint}" not found).`
+    ) ?? void 0;
+    if (detected?.entrypoint) {
+      (0, import_build_utils13.debug)(
+        `Resolved Python entrypoint to "${detected.entrypoint}" (configured "${entrypoint}" not found).`
       );
-      entrypoint = detected;
+      entrypoint = detected.entrypoint;
     } else {
       const searchedList = PYTHON_CANDIDATE_ENTRYPOINTS.join(", ");
-      throw new import_build_utils12.NowBuildError({
+      entrypointNotFound = new import_build_utils13.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`,
@@ -5425,120 +5471,58 @@ var build = async ({
       });
     }
   }
-  const entryDirectory = (0, import_path10.dirname)(entrypoint);
-  const pyprojectDir = findDir({
-    file: "pyproject.toml",
-    entryDirectory,
-    workPath,
-    fsFiles
-  });
-  const pipfileLockDir = findDir({
-    file: "Pipfile.lock",
-    entryDirectory,
-    workPath,
-    fsFiles
-  });
-  const pythonVersionFileDir = findDir({
-    file: ".python-version",
-    entryDirectory,
-    workPath,
-    fsFiles
-  });
-  const { pythonVersion, declaredPythonVersion } = await builderSpan.child("vc.builder.python.version").trace(async (versionSpan) => {
-    let declared;
-    if (pythonVersionFileDir) {
-      try {
-        const content = await readFile2(
-          (0, import_path10.join)(pythonVersionFileDir, ".python-version"),
-          "utf8"
-        );
-        const version2 = parsePythonVersionFile(content);
-        if (version2) {
-          declared = { version: version2, source: ".python-version" };
-          (0, import_build_utils12.debug)(`Found Python version ${version2} in .python-version`);
-        }
-      } catch (err) {
-        (0, import_build_utils12.debug)("Failed to read .python-version file", err);
-      }
-    }
-    if (!declared && pyprojectDir) {
-      let requiresPython;
-      try {
-        const pyproject = await (0, import_build_utils13.readConfigFile)((0, import_path10.join)(pyprojectDir, "pyproject.toml"));
-        requiresPython = pyproject?.project?.["requires-python"];
-      } catch (err) {
-        (0, import_build_utils12.debug)("Failed to parse pyproject.toml", err);
-      }
-      if (typeof requiresPython === "string" && requiresPython.trim()) {
-        declared = {
-          version: requiresPython.trim(),
-          source: "pyproject.toml"
-        };
-        (0, import_build_utils12.debug)(`Found requires-python "${requiresPython}" in pyproject.toml`);
-      }
-    }
-    if (!declared && pipfileLockDir) {
-      let lock = {};
-      const pipfileLockPath = (0, import_path10.join)(pipfileLockDir, "Pipfile.lock");
-      try {
-        const pipfileLockContent = await readFile2(pipfileLockPath, "utf8");
-        try {
-          lock = JSON.parse(pipfileLockContent);
-        } catch (err) {
-          console.log(
-            `Failed to parse "Pipfile.lock". File content:
-${pipfileLockContent}`
-          );
-          throw err;
-        }
-      } catch (err) {
-        throw new import_build_utils12.NowBuildError({
-          code: "INVALID_PIPFILE_LOCK",
-          message: "Unable to parse Pipfile.lock"
-        });
-      }
-      const pyFromLock = lock?._meta?.requires?.python_version;
-      if (pyFromLock) {
-        declared = { version: pyFromLock, source: "Pipfile.lock" };
-        (0, import_build_utils12.debug)(`Found Python version ${pyFromLock} in Pipfile.lock`);
-      }
-    }
-    const resolved = getSupportedPythonVersion({
+  if (entrypointNotFound && detected?.baseDir === void 0) {
+    throw entrypointNotFound;
+  }
+  const entryDirectory = detected?.baseDir ?? (0, import_path12.dirname)(entrypoint);
+  const entrypointAbsDir = (0, import_path12.join)(workPath, entryDirectory);
+  const rootDir = repoRootPath ?? workPath;
+  const pythonPackage = await builderSpan.child("vc.builder.python.discover").trace(
+    () => discoverPackage({
+      entrypointDir: entrypointAbsDir,
+      rootDir
+    })
+  );
+  const { pythonVersion, pinVersionFilePath } = await builderSpan.child("vc.builder.python.version").trace((versionSpan) => {
+    const resolution = resolvePythonVersion({
       isDev: meta.isDev,
-      declaredPythonVersion: declared
+      pythonPackage,
+      rootDir
     });
     versionSpan.setAttributes({
-      "python.version": resolved.version,
-      "python.versionSource": declared?.source
+      "python.version": pythonVersionString(resolution.pythonVersion),
+      "python.versionSource": resolution.versionSource
     });
-    return { pythonVersion: resolved, declaredPythonVersion: declared };
+    return resolution;
   });
-  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_path10.join)(pyprojectDir, ".python-version");
-    await writeFile(pythonVersionFilePath, `${pythonVersion.version}
-`);
+  if (pinVersionFilePath) {
     console.log(
-      `Writing .python-version file with version ${pythonVersion.version}`
+      `Writing .python-version file with version ${pythonVersionString(pythonVersion)}`
+    );
+    await writeFile(
+      pinVersionFilePath,
+      `${pythonVersionString(pythonVersion)}
+`
     );
   }
-  fsFiles = await (0, import_build_utils12.glob)("**", workPath);
-  const venvPath = (0, import_path10.join)(workPath, ".vercel", "python", ".venv");
+  fsFiles = await (0, import_build_utils13.glob)("**", workPath);
+  const venvPath = (0, import_path12.join)(workPath, ".vercel", "python", ".venv");
+  const uvCacheDir = getUvCacheDir(workPath);
   await builderSpan.child("vc.builder.python.venv").trace(async () => {
     await ensureVenv({
       pythonPath: pythonVersion.pythonPath,
-      venvPath
+      venvPath,
+      uvCacheDir
     });
   });
-  if ((0, import_build_utils12.isPythonFramework)(framework)) {
+  if ((0, import_build_utils13.isPythonFramework)(framework)) {
     const {
       cliType,
       lockfileVersion,
       packageJsonPackageManager,
       turboSupportsCorepackHome
-    } = await (0, import_build_utils12.scanParentDirs)(workPath, true);
-    spawnEnv = (0, import_build_utils12.getEnvForPackageManager)({
+    } = await (0, import_build_utils13.scanParentDirs)(workPath, true);
+    spawnEnv = (0, import_build_utils13.getEnvForPackageManager)({
       cliType,
       lockfileVersion,
       packageJsonPackageManager,
@@ -5557,14 +5541,14 @@ ${pipfileLockContent}`
     }
   }
   const baseEnv = spawnEnv || process.env;
-  const pythonEnv = createVenvEnv(venvPath, baseEnv);
+  const pythonEnv = createVenvEnv(venvPath, baseEnv, uvCacheDir);
   pythonEnv.VERCEL_PYTHON_VENV_PATH = venvPath;
   let assumeDepsInstalled = false;
   let uv;
   try {
     const uvPath = await getUvBinaryOrInstall(pythonVersion.pythonPath);
     console.log(`Using uv at "${uvPath}"`);
-    uv = new UvRunner(uvPath);
+    uv = new UvRunner(uvPath, uvCacheDir);
   } catch (err) {
     console.log("Failed to install or locate uv");
     throw new Error(
@@ -5575,14 +5559,14 @@ ${pipfileLockContent}`
   let uvProjectDir = null;
   let projectName;
   let noBuildCheckFailed = false;
-  await builderSpan.child(import_build_utils12.BUILDER_INSTALLER_STEP, {
+  await builderSpan.child(import_build_utils13.BUILDER_INSTALLER_STEP, {
     installCommand: projectInstallCommand || void 0
   }).trace(async () => {
     if (projectInstallCommand) {
       console.log(
         `Running "install" command: \`${projectInstallCommand}\`...`
       );
-      await (0, import_build_utils12.execCommand)(projectInstallCommand, {
+      await (0, import_build_utils13.execCommand)(projectInstallCommand, {
         env: pythonEnv,
         cwd: workPath
       });
@@ -5603,21 +5587,16 @@ ${pipfileLockContent}`
     if (!assumeDepsInstalled) {
       const { projectDir, lockPath, lockFileProvidedByUser } = await ensureUvProject({
         workPath,
-        entryDirectory,
-        repoRootPath,
-        pythonVersion: pythonVersion.version,
+        rootDir,
+        pythonPackage,
+        pythonVersion: pythonVersionString(pythonVersion),
         uv,
         generateLockFile: true,
         requireBinaryWheels: false
       });
       uvLockPath = lockPath;
       uvProjectDir = projectDir;
-      const installInfo = await detectInstallSource({
-        workPath,
-        entryDirectory,
-        repoRootPath
-      });
-      projectName = installInfo.pythonPackage?.manifest?.data?.project?.name;
+      projectName = pythonPackage?.manifest?.data?.project?.name;
       if (lockFileProvidedByUser) {
         try {
           await uv.sync({
@@ -5629,7 +5608,7 @@ ${pipfileLockContent}`
           });
         } catch (err) {
           noBuildCheckFailed = true;
-          (0, import_build_utils12.debug)(
+          (0, import_build_utils13.debug)(
             `--no-build check failed: ${err instanceof Error ? err.message : String(err)}`
           );
         }
@@ -5642,15 +5621,15 @@ ${pipfileLockContent}`
       });
     }
   });
-  if ((0, import_build_utils12.isPythonFramework)(framework)) {
+  if ((0, import_build_utils13.isPythonFramework)(framework)) {
     const projectBuildCommand = config?.projectSettings?.buildCommand ?? // fallback if provided directly on config (some callers set this)
     config?.buildCommand;
-    await builderSpan.child(import_build_utils12.BUILDER_COMPILE_STEP, {
+    await builderSpan.child(import_build_utils13.BUILDER_COMPILE_STEP, {
       buildCommand: projectBuildCommand || void 0
     }).trace(async () => {
       if (projectBuildCommand) {
         console.log(`Running "${projectBuildCommand}"`);
-        await (0, import_build_utils12.execCommand)(projectBuildCommand, {
+        await (0, import_build_utils13.execCommand)(projectBuildCommand, {
           env: pythonEnv,
           cwd: workPath
         });
@@ -5663,19 +5642,32 @@ ${pipfileLockContent}`
       }
     });
   }
+  const hookResult = await runFrameworkHook(framework, {
+    pythonEnv,
+    projectDir: (0, import_path12.join)(workPath, entryDirectory),
+    entrypoint,
+    detected
+  });
+  if (entrypointNotFound && hookResult?.entrypoint) {
+    entrypoint = hookResult.entrypoint;
+    entrypointNotFound = void 0;
+  }
+  if (entrypointNotFound) {
+    throw entrypointNotFound;
+  }
   const runtimeDep = baseEnv.VERCEL_RUNTIME_PYTHON || `vercel-runtime==${VERCEL_RUNTIME_VERSION}`;
-  (0, import_build_utils12.debug)(`Installing ${runtimeDep}`);
+  (0, import_build_utils13.debug)(`Installing ${runtimeDep}`);
   await uv.pip({
     venvPath,
-    projectDir: (0, import_path10.join)(workPath, entryDirectory),
+    projectDir: (0, import_path12.join)(workPath, entryDirectory),
     args: ["install", runtimeDep]
   });
   if (shouldInstallVercelWorkers) {
     const workersDep = baseEnv.VERCEL_WORKERS_PYTHON || `vercel-workers==${VERCEL_WORKERS_VERSION}`;
-    (0, import_build_utils12.debug)(`Installing ${workersDep}`);
+    (0, import_build_utils13.debug)(`Installing ${workersDep}`);
     await uv.pip({
       venvPath,
-      projectDir: (0, import_path10.join)(workPath, entryDirectory),
+      projectDir: (0, import_path12.join)(workPath, entryDirectory),
       args: ["install", workersDep]
     });
   }
@@ -5683,12 +5675,26 @@ ${pipfileLockContent}`
   if (quirksResult.buildEnv) {
     Object.assign(pythonEnv, quirksResult.buildEnv);
   }
-  (0, import_build_utils12.debug)("Entrypoint is", entrypoint);
+  (0, import_build_utils13.debug)("Entrypoint is", entrypoint);
   const moduleName = entrypoint.replace(/\//g, ".").replace(/\.py$/i, "");
+  const handlerFunction = typeof config?.handlerFunction === "string" ? config.handlerFunction : void 0;
+  if (handlerFunction) {
+    const entrypointPath = (0, import_path12.join)(workPath, entrypoint);
+    const source = await import_fs10.default.promises.readFile(entrypointPath, "utf-8");
+    const found = await (0, import_python_analysis7.containsTopLevelCallable)(source, handlerFunction);
+    if (!found) {
+      throw new import_build_utils13.NowBuildError({
+        code: "PYTHON_HANDLER_NOT_FOUND",
+        message: `Handler function "${handlerFunction}" not found in ${entrypoint}. Ensure it is defined at the module's top level.`
+      });
+    }
+  }
   const vendorDir = resolveVendorDir();
   const suffix = meta.isDev && !entrypoint.endsWith(".py") ? ".py" : "";
   const entrypointWithSuffix = `${entrypoint}${suffix}`;
-  (0, import_build_utils12.debug)("Entrypoint with suffix is", entrypointWithSuffix);
+  (0, import_build_utils13.debug)("Entrypoint with suffix is", entrypointWithSuffix);
+  const handlerFuncEnvLine = handlerFunction ? `
+  "__VC_HANDLER_FUNC_NAME": "${handlerFunction}",` : "";
   const runtimeTrampoline = `
 import importlib
 import os
@@ -5702,7 +5708,7 @@ os.environ.update({
   "__VC_HANDLER_MODULE_NAME": "${moduleName}",
   "__VC_HANDLER_ENTRYPOINT": "${entrypointWithSuffix}",
   "__VC_HANDLER_ENTRYPOINT_ABS": os.path.join(_here, "${entrypointWithSuffix}"),
-  "__VC_HANDLER_VENDOR_DIR": "${vendorDir}",
+  "__VC_HANDLER_VENDOR_DIR": "${vendorDir}",${handlerFuncEnvLine}
 })
 
 _vendor_rel = '${vendorDir}'
@@ -5752,7 +5758,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_utils12.glob)("**", globOptions);
+  const files = await (0, import_build_utils13.glob)("**", globOptions);
   const depExternalizer = new PythonDependencyExternalizer({
     venvPath,
     vendorDir,
@@ -5764,7 +5770,7 @@ from vercel_runtime.vc_init import vc_handler
     pythonPath: pythonVersion.pythonPath,
     hasCustomCommand,
     alwaysBundlePackages: [
-      ...quirksResult.alwaysBundlePackages,
+      ...quirksResult.alwaysBundlePackages ?? [],
       ...shouldInstallVercelWorkers ? ["vercel-workers", "vercel_workers"] : []
     ]
   });
@@ -5785,12 +5791,12 @@ from vercel_runtime.vc_init import vc_handler
     }
   });
   const handlerPyFilename = "vc__handler__python";
-  files[`${handlerPyFilename}.py`] = new import_build_utils12.FileBlob({ data: runtimeTrampoline });
+  files[`${handlerPyFilename}.py`] = new import_build_utils13.FileBlob({ data: runtimeTrampoline });
   if (config.framework === "fasthtml") {
     const { SESSKEY = "" } = process.env;
-    files[".sesskey"] = new import_build_utils12.FileBlob({ data: `"${SESSKEY}"` });
+    files[".sesskey"] = new import_build_utils13.FileBlob({ data: `"${SESSKEY}"` });
   }
-  const output = new import_build_utils12.Lambda({
+  const output = new import_build_utils13.Lambda({
     files,
     handler: `${handlerPyFilename}.vc_handler`,
     runtime: pythonVersion.runtime,
@@ -5799,9 +5805,44 @@ from vercel_runtime.vc_init import vc_handler
   });
   return { output };
 };
+async function readBuildOutputV3Config(workPath) {
+  try {
+    const configPath = (0, import_path12.join)(workPath, ".vercel", "output", "config.json");
+    return JSON.parse(await import_fs10.default.promises.readFile(configPath, "utf8"));
+  } catch (err) {
+    if (err.code !== "ENOENT") {
+      throw err;
+    }
+  }
+  return void 0;
+}
+var prepareCache = async ({
+  repoRootPath,
+  workPath
+}) => {
+  const cacheFiles = {};
+  const root = repoRootPath || workPath;
+  const ignore = ["**/*.pyc", "**/__pycache__/**"];
+  const configV3 = await readBuildOutputV3Config(workPath);
+  if (configV3?.cache && Array.isArray(configV3.cache)) {
+    for (const cacheGlob of configV3.cache) {
+      Object.assign(cacheFiles, await (0, import_build_utils13.glob)(cacheGlob, workPath));
+    }
+    return cacheFiles;
+  }
+  Object.assign(
+    cacheFiles,
+    await (0, import_build_utils13.glob)("**/.vercel/python/.venv/**", { cwd: root, ignore })
+  );
+  Object.assign(
+    cacheFiles,
+    await (0, import_build_utils13.glob)("**/.vercel/python/cache/uv/**", { cwd: root, ignore })
+  );
+  return cacheFiles;
+};
 var shouldServe = (opts) => {
   const framework = opts.config.framework;
-  if ((0, import_build_utils12.isPythonFramework)(framework)) {
+  if ((0, import_build_utils13.isPythonFramework)(framework)) {
     const requestPath = opts.requestPath.replace(/\/$/, "");
     if (requestPath.startsWith("api") && opts.hasMatched) {
       return false;
@@ -5820,7 +5861,7 @@ var defaultShouldServe = ({
   if (entrypoint === requestPath && hasProp(files, entrypoint)) {
     return true;
   }
-  const { dir, name } = (0, import_path10.parse)(entrypoint);
+  const { dir, name } = (0, import_path12.parse)(entrypoint);
   if (name === "index" && dir === requestPath && hasProp(files, entrypoint)) {
     return true;
   }
@@ -5829,16 +5870,6 @@ 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,
@@ -5846,6 +5877,8 @@ function parsePythonVersionFile(content) {
   downloadFilesInWorkPath,
   installRequirement,
   installRequirementsFile,
+  prepareCache,
+  runFrameworkHook,
   shouldServe,
   startDevServer,
   version