@vercel/python 6.20.2 → 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;
       }
@@ -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;
           }
@@ -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: join11, 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 + join11(pathPart, cmd);
+      return prefix + join12(pathPart, cmd);
     };
     var which2 = async (cmd, opt = {}) => {
       const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
@@ -2862,20 +2862,22 @@ __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_path11 = require("path");
+var import_fs10 = __toESM(require("fs"));
+var import_path12 = require("path");
 
 // src/package-versions.ts
-var VERCEL_RUNTIME_VERSION = "0.5.6";
+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());
@@ -2902,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;
@@ -2986,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(
@@ -3051,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
     };
@@ -3158,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) {
@@ -3201,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);
@@ -3215,6 +3226,7 @@ async function ensureVenv({
   pythonPath,
   venvPath,
   uvPath,
+  uvCacheDir,
   quiet
 }) {
   const marker = (0, import_path3.join)(venvPath, "pyvenv.cfg");
@@ -3228,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]);
   }
@@ -3735,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) {
@@ -4202,13 +4216,14 @@ async function calculatePerPackageSizes(venvPath) {
 
 // src/start-dev-server.ts
 var import_child_process2 = require("child_process");
-var import_fs5 = require("fs");
+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_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");
@@ -4231,6 +4246,20 @@ function getCandidateEntrypointsInDirs(dirs) {
     )
   );
 }
+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_path7.join)(workPath, "pyproject.toml"));
   if (!pyprojectData)
@@ -4244,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;
@@ -4292,48 +4331,33 @@ 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_path7.join)(workPath, rootDir);
-      const wsgiEntry = await (0, import_build_utils6.getDjangoEntrypoint)(currPath);
-      if (wsgiEntry) {
-        const fullWsgiEntry = import_path7.posix.join(rootDir, wsgiEntry);
-        if (fsFiles[fullWsgiEntry]) {
-          (0, import_build_utils6.debug)(`Using Django WSGI entrypoint: ${fullWsgiEntry}`);
-          return fullWsgiEntry;
-        }
+      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
@@ -4424,10 +4448,10 @@ async function syncDependencies({
   }
   if (manifest?.origin && manifestType === "pyproject.toml") {
     const syncDir = (0, import_path8.join)(workPath, ".vercel", "python", "sync");
-    (0, import_fs5.mkdirSync)(syncDir, { recursive: true });
+    (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_fs5.writeFileSync)(tempPyproject, content, "utf8");
+    (0, import_fs6.writeFileSync)(tempPyproject, content, "utf8");
     manifestPath = tempPyproject;
     (0, import_build_utils8.debug)(
       `Wrote converted ${manifest.origin.kind} manifest to ${tempPyproject}`
@@ -4588,20 +4612,25 @@ function installGlobalCleanupHandlers() {
 function createDevShim(workPath, entry, modulePath) {
   try {
     const vercelPythonDir = (0, import_path8.join)(workPath, ".vercel", "python");
-    (0, import_fs5.mkdirSync)(vercelPythonDir, { recursive: true });
+    (0, import_fs6.mkdirSync)(vercelPythonDir, { recursive: true });
     let qualifiedModule = modulePath;
     let extraPythonPath;
-    if ((0, import_fs5.existsSync)((0, import_path8.join)(workPath, "__init__.py"))) {
+    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_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, "..", `${DEV_SHIM_MODULE}.py`);
-    const template = (0, import_fs5.readFileSync)(templatePath, "utf8");
+    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) {
@@ -4616,7 +4645,12 @@ async function getMultiServicePythonRunner(workPath, env, systemPython, uvPath)
     return { command: pythonCmd, args: [] };
   }
   const venvPath = (0, import_path8.join)(workPath, ".venv");
-  await ensureVenv({ pythonPath: systemPython, venvPath, uvPath, quiet: true });
+  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);
@@ -4634,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 {
@@ -4678,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;
@@ -4851,7 +4895,7 @@ var matplotlibQuirk = {
 };
 
 // src/quirks/litellm.ts
-var import_fs6 = __toESM(require("fs"));
+var import_fs7 = __toESM(require("fs"));
 var import_path9 = require("path");
 var import_build_utils9 = require("@vercel/build-utils");
 var LAMBDA_ROOT = "/var/task";
@@ -4865,7 +4909,7 @@ async function findConfigFile(workPath) {
   for (const name of CONFIG_CANDIDATES) {
     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 {
     }
@@ -4887,7 +4931,7 @@ var litellmQuirk = {
         "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;
@@ -4914,7 +4958,7 @@ var litellmQuirk = {
 };
 
 // src/quirks/prisma.ts
-var import_fs7 = __toESM(require("fs"));
+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");
@@ -4956,7 +5000,7 @@ async function findUserSchema(workPath) {
   if (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}`);
@@ -4969,7 +5013,7 @@ async function findUserSchema(workPath) {
   ];
   for (const candidate of candidates) {
     try {
-      await import_fs7.default.promises.access(candidate);
+      await import_fs8.default.promises.access(candidate);
       return candidate;
     } catch {
     }
@@ -4980,7 +5024,7 @@ 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;
   }
@@ -5005,7 +5049,7 @@ async function cleanCacheArtifacts(cacheDir, 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)}`
@@ -5039,7 +5083,7 @@ var prismaQuirk = {
     let sitePackages;
     for (const dir of sitePackagesDirs) {
       try {
-        await import_fs7.default.promises.access((0, import_path10.join)(dir, "prisma"));
+        await import_fs8.default.promises.access((0, import_path10.join)(dir, "prisma"));
         sitePackages = dir;
         break;
       } catch {
@@ -5052,14 +5096,14 @@ var prismaQuirk = {
       return {};
     }
     const cacheDir = (0, import_path10.join)(sitePackages, "prisma", "__bincache__");
-    await import_fs7.default.promises.mkdir(cacheDir, { recursive: true });
+    await import_fs8.default.promises.mkdir(cacheDir, { recursive: true });
     const generateEnv = {
       ...pythonEnv,
       PRISMA_BINARY_CACHE_DIR: cacheDir
     };
     const generatedDir = (0, import_path10.join)(workPath, "_prisma_generated");
     const dummySchemaPath = (0, import_path10.join)(workPath, DUMMY_SCHEMA_NAME);
-    await import_fs7.default.promises.writeFile(
+    await import_fs8.default.promises.writeFile(
       dummySchemaPath,
       buildDummySchema(generatedDir)
     );
@@ -5090,18 +5134,18 @@ var prismaQuirk = {
     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_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;
       }
@@ -5119,15 +5163,15 @@ var prismaQuirk = {
       });
     }
     const shimPath = (0, import_path10.join)(cacheDir, "openssl");
-    await import_fs7.default.promises.writeFile(
+    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();
@@ -5299,22 +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 writeFile = import_fs8.default.promises.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_path11.join)(workPath, ".now", "cache") } = meta;
-    const destCache = (0, import_path11.join)(devCacheDir, (0, import_path11.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;
@@ -5328,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,
@@ -5343,28 +5439,31 @@ var build = async ({
   });
   try {
     if (meta.isDev) {
-      const setupCfg = (0, import_path11.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`,
@@ -5372,8 +5471,11 @@ var build = async ({
       });
     }
   }
-  const entryDirectory = (0, import_path11.dirname)(entrypoint);
-  const entrypointAbsDir = (0, import_path11.join)(workPath, entryDirectory);
+  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({
@@ -5403,22 +5505,24 @@ var build = async ({
 `
     );
   }
-  fsFiles = await (0, import_build_utils12.glob)("**", workPath);
-  const venvPath = (0, import_path11.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,
@@ -5437,14 +5541,14 @@ var build = async ({
     }
   }
   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(
@@ -5455,14 +5559,14 @@ var build = async ({
   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
       });
@@ -5504,7 +5608,7 @@ var build = async ({
           });
         } 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)}`
           );
         }
@@ -5517,15 +5621,15 @@ var build = async ({
       });
     }
   });
-  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
         });
@@ -5538,19 +5642,32 @@ var build = async ({
       }
     });
   }
+  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_path11.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_path11.join)(workPath, entryDirectory),
+      projectDir: (0, import_path12.join)(workPath, entryDirectory),
       args: ["install", workersDep]
     });
   }
@@ -5558,12 +5675,26 @@ var build = async ({
   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
@@ -5577,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}'
@@ -5627,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,
@@ -5660,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,
@@ -5674,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;
@@ -5695,7 +5861,7 @@ var defaultShouldServe = ({
   if (entrypoint === requestPath && hasProp(files, entrypoint)) {
     return true;
   }
-  const { dir, name } = (0, import_path11.parse)(entrypoint);
+  const { dir, name } = (0, import_path12.parse)(entrypoint);
   if (name === "index" && dir === requestPath && hasProp(files, entrypoint)) {
     return true;
   }
@@ -5711,6 +5877,8 @@ function hasProp(obj, key) {
   downloadFilesInWorkPath,
   installRequirement,
   installRequirementsFile,
+  prepareCache,
+  runFrameworkHook,
   shouldServe,
   startDevServer,
   version