@vercel/python 6.28.0 → 6.30.0

package/dist/index.js

@@ -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 debug12;
+    var debug13;
     if (typeof process === "object" && process.env && process.env.NODE_DEBUG && /\bsemver\b/i.test(process.env.NODE_DEBUG)) {
-      debug12 = function() {
+      debug13 = function() {
         var args = Array.prototype.slice.call(arguments, 0);
         args.unshift("SEMVER");
         console.log.apply(console, args);
       };
     } else {
-      debug12 = function() {
+      debug13 = 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++) {
-      debug12(i, src[i]);
+      debug13(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);
       }
-      debug12("SemVer", version2, options);
+      debug13("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) {
-      debug12("SemVer.compare", this.version, this.options, other);
+      debug13("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];
-        debug12("prerelease compare", i2, a, b);
+        debug13("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(" ");
-      debug12("comparator", comp, options);
+      debug13("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;
       }
-      debug12("comp", this);
+      debug13("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) {
-      debug12("Comparator.test", version2, this.options.loose);
+      debug13("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);
-      debug12("hyphen replace", range);
+      debug13("hyphen replace", range);
       range = range.replace(safeRe[COMPARATORTRIM], comparatorTrimReplace);
-      debug12("comparator trim", range, safeRe[COMPARATORTRIM]);
+      debug13("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) {
-      debug12("comp", comp, options);
+      debug13("comp", comp, options);
       comp = replaceCarets(comp, options);
-      debug12("caret", comp);
+      debug13("caret", comp);
       comp = replaceTildes(comp, options);
-      debug12("tildes", comp);
+      debug13("tildes", comp);
       comp = replaceXRanges(comp, options);
-      debug12("xrange", comp);
+      debug13("xrange", comp);
       comp = replaceStars(comp, options);
-      debug12("stars", comp);
+      debug13("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) {
-        debug12("tilde", comp, _, M, m, p, pr);
+        debug13("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) {
-          debug12("replaceTilde pr", pr);
+          debug13("replaceTilde pr", pr);
           ret = ">=" + M + "." + m + "." + p + "-" + pr + " <" + M + "." + (+m + 1) + ".0";
         } else {
           ret = ">=" + M + "." + m + "." + p + " <" + M + "." + (+m + 1) + ".0";
         }
-        debug12("tilde return", ret);
+        debug13("tilde return", ret);
         return ret;
       });
     }
@@ -1138,10 +1138,10 @@ var require_semver = __commonJS({
       }).join(" ");
     }
     function replaceCaret(comp, options) {
-      debug12("caret", comp, options);
+      debug13("caret", comp, options);
       var r = options.loose ? safeRe[CARETLOOSE] : safeRe[CARET];
       return comp.replace(r, function(_, M, m, p, pr) {
-        debug12("caret", comp, _, M, m, p, pr);
+        debug13("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) {
-          debug12("replaceCaret pr", pr);
+          debug13("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 {
-          debug12("no pr");
+          debug13("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";
           }
         }
-        debug12("caret return", ret);
+        debug13("caret return", ret);
         return ret;
       });
     }
     function replaceXRanges(comp, options) {
-      debug12("replaceXRanges", comp, options);
+      debug13("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) {
-        debug12("xRange", comp, ret, gtlt, M, m, p, pr);
+        debug13("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";
         }
-        debug12("xRange return", ret);
+        debug13("xRange return", ret);
         return ret;
       });
     }
     function replaceStars(comp, options) {
-      debug12("replaceStars", comp, options);
+      debug13("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++) {
-          debug12(set[i2].semver);
+          debug13(set[i2].semver);
           if (set[i2].semver === ANY) {
             continue;
           }
@@ -3217,6 +3217,7 @@ __export(src_exports, {
   downloadFilesInWorkPath: () => downloadFilesInWorkPath,
   installRequirement: () => installRequirement,
   installRequirementsFile: () => installRequirementsFile,
+  prepareCache: () => prepareCache,
   runFrameworkHook: () => runFrameworkHook,
   shouldServe: () => shouldServe,
   startDevServer: () => startDevServer,
@@ -3228,11 +3229,11 @@ var import_fs11 = __toESM(require("fs"));
 var import_path13 = require("path");
 
 // src/package-versions.ts
-var VERCEL_RUNTIME_VERSION = "0.11.0";
-var VERCEL_WORKERS_VERSION = "0.0.13";
+var VERCEL_RUNTIME_VERSION = "0.12.0";
+var VERCEL_WORKERS_VERSION = "0.0.15";
 
 // src/index.ts
-var import_build_utils14 = require("@vercel/build-utils");
+var import_build_utils15 = require("@vercel/build-utils");
 
 // src/install.ts
 var import_execa3 = __toESM(require_execa());
@@ -3261,14 +3262,19 @@ var import_build_utils = require("@vercel/build-utils");
 var UV_VERSION = "0.10.11";
 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;
@@ -3317,7 +3323,7 @@ var UvRunner = class {
   }
   async sync(options) {
     const { venvPath, projectDir, locked, frozen, noBuild, noInstallProject } = options;
-    const args = ["sync", "--active", "--no-dev", "--link-mode", "copy"];
+    const args = ["sync", "--active", "--no-dev", "--link-mode", "hardlink"];
     if (frozen) {
       args.push("--frozen");
     } else if (locked) {
@@ -3366,6 +3372,24 @@ var UvRunner = class {
     const fullArgs = ["pip", ...args];
     await this.runUvCmd(fullArgs, projectDir, venvPath);
   }
+  /**
+   * Prune the uv cache for CI: removes pre-built wheels and unzipped source
+   * distributions while retaining source-built wheels.
+   */
+  async cachePrune() {
+    const args = ["cache", "prune", "--ci"];
+    const pretty = `uv ${args.join(" ")}`;
+    (0, import_build_utils.debug)(`Running "${pretty}"...`);
+    try {
+      await (0, import_execa.default)(this.uvPath, args, {
+        env: getProtectedUvEnv(process.env, this.uvCacheDir)
+      });
+    } catch (err) {
+      (0, import_build_utils.debug)(
+        `Warning: ${pretty} failed: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  }
   async runUvCmd(args, cwd, venvPath) {
     const pretty = `uv ${args.join(" ")}`;
     (0, import_build_utils.debug)(`Running "${pretty}"...`);
@@ -3392,7 +3416,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
     };
@@ -3499,11 +3523,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) {
@@ -3542,9 +3570,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);
@@ -3552,26 +3580,60 @@ function createVenvEnv(venvPath, baseEnv = process.env) {
   env.PATH = existingPath ? `${binDir}${import_path3.delimiter}${existingPath}` : binDir;
   return env;
 }
+async function readVenvPythonVersion(pyvenvCfgPath) {
+  try {
+    const content = await import_fs2.default.promises.readFile(pyvenvCfgPath, "utf-8");
+    const match = content.match(/^version\s*=\s*(\d+)\.(\d+)/m);
+    return match ? `${match[1]}.${match[2]}` : null;
+  } catch {
+    return null;
+  }
+}
 async function ensureVenv({
-  pythonPath,
+  pythonVersion,
   venvPath,
   uvPath,
+  uvCacheDir,
   quiet
 }) {
   const marker = (0, import_path3.join)(venvPath, "pyvenv.cfg");
+  let venvExists = false;
   try {
     await import_fs2.default.promises.access(marker);
-    return;
+    venvExists = true;
   } catch {
   }
-  await import_fs2.default.promises.mkdir(venvPath, { recursive: true });
-  if (!quiet) {
-    console.log(`Creating virtual environment at "${venvPath}"...`);
+  if (venvExists && pythonVersion.major != null && pythonVersion.minor != null) {
+    const expected = `${pythonVersion.major}.${pythonVersion.minor}`;
+    const cachedVersion = await readVenvPythonVersion(marker);
+    if (cachedVersion && cachedVersion !== expected) {
+      if (!quiet) {
+        console.log(
+          `Cached venv Python ${cachedVersion} differs from requested ${expected}, recreating...`
+        );
+      }
+      await import_fs2.default.promises.rm(venvPath, { recursive: true, force: true });
+      venvExists = false;
+    }
+  }
+  if (venvExists) {
+    (0, import_build_utils2.debug)(`Refreshing cached virtual environment at "${venvPath}"`);
+  } else {
+    await import_fs2.default.promises.mkdir(venvPath, { recursive: true });
+    if (!quiet) {
+      console.log(`Creating virtual environment at "${venvPath}"...`);
+    }
   }
   if (uvPath) {
-    await (0, import_execa2.default)(uvPath, ["venv", venvPath]);
+    const args = ["venv", venvPath, "--allow-existing"];
+    if (pythonVersion.major != null && pythonVersion.minor != null) {
+      args.push("--python", `${pythonVersion.major}.${pythonVersion.minor}`);
+    }
+    await (0, import_execa2.default)(uvPath, args, {
+      env: getProtectedUvEnv(process.env, uvCacheDir)
+    });
   } else {
-    await (0, import_execa2.default)(pythonPath, ["-m", "venv", venvPath]);
+    await (0, import_execa2.default)(pythonVersion.pythonPath, ["-m", "venv", venvPath]);
   }
 }
 function getVenvPythonBin(venvPath) {
@@ -3900,6 +3962,15 @@ function isInstalled(pv) {
 }
 
 // src/install.ts
+async function restoreCachedLock(cachedLockPath, projectDir) {
+  if (!cachedLockPath)
+    return;
+  const targetLockPath = (0, import_path5.join)(projectDir, "uv.lock");
+  if (import_fs3.default.existsSync(cachedLockPath) && !import_fs3.default.existsSync(targetLockPath)) {
+    (0, import_build_utils4.debug)("Restoring cached uv.lock");
+    await import_fs3.default.promises.copyFile(cachedLockPath, targetLockPath);
+  }
+}
 var makeDependencyCheckCode = (dependency) => `
 from importlib import util
 dep = '${dependency}'.replace('-', '_')
@@ -4024,8 +4095,8 @@ async function ensureUvProject({
   pythonPackage,
   pythonVersion,
   uv,
-  generateLockFile = false,
-  requireBinaryWheels = false
+  requireBinaryWheels = false,
+  cachedLockPath
 }) {
   const { manifestType } = detectInstallSource(pythonPackage, rootDir);
   const manifest = pythonPackage.manifest;
@@ -4077,18 +4148,13 @@ async function ensureUvProject({
     if (workspaceLockFile) {
       lockPath = (0, import_path5.join)(rootDir, workspaceLockFile.path);
     } else {
+      await restoreCachedLock(cachedLockPath, projectDir);
       await uv.lock({
         projectDir,
         venvPath,
         ...requireBinaryWheels ? { noBuild: true, upgrade: true } : {}
       });
-    }
-    if (generateLockFile && !lockPath) {
-      await uv.lock({
-        projectDir,
-        venvPath,
-        ...requireBinaryWheels ? { noBuild: true, upgrade: true } : {}
-      });
+      lockPath = (0, import_path5.join)(projectDir, "uv.lock");
     }
   } else {
     projectDir = workPath;
@@ -4104,6 +4170,7 @@ async function ensureUvProject({
     });
     const content = (0, import_python_analysis2.stringifyManifest)(minimalManifest);
     await import_fs3.default.promises.writeFile(pyprojectPath, content);
+    await restoreCachedLock(cachedLockPath, projectDir);
     await uv.lock({
       projectDir,
       venvPath,
@@ -4136,7 +4203,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) {
@@ -5004,7 +5071,7 @@ var diagnostics = async ({
 var import_child_process2 = require("child_process");
 var import_fs7 = require("fs");
 var import_path9 = require("path");
-var import_build_utils9 = require("@vercel/build-utils");
+var import_build_utils10 = require("@vercel/build-utils");
 var import_get_port = __toESM(require_get_port());
 var import_is_port_reachable = __toESM(require_is_port_reachable());
 
@@ -5013,6 +5080,7 @@ var import_fs6 = __toESM(require("fs"));
 var import_path8 = require("path");
 var import_build_utils7 = require("@vercel/build-utils");
 var import_build_utils8 = require("@vercel/build-utils");
+var import_build_utils9 = require("@vercel/build-utils");
 var import_python_analysis5 = require("@vercel/python-analysis");
 var PYTHON_ENTRYPOINT_FILENAMES = [
   "app",
@@ -5049,7 +5117,7 @@ async function checkEntrypoint(workPath, relPath) {
   return (0, import_python_analysis5.findAppOrHandler)(content);
 }
 async function getPyprojectEntrypoint(workPath) {
-  const pyprojectData = await (0, import_build_utils8.readConfigFile)((0, import_path8.join)(workPath, "pyproject.toml"));
+  const pyprojectData = await (0, import_build_utils9.readConfigFile)((0, import_path8.join)(workPath, "pyproject.toml"));
   if (!pyprojectData)
     return null;
   const scripts = pyprojectData.project?.scripts;
@@ -5074,7 +5142,7 @@ async function findValidEntrypoint(workPath, candidates) {
   for (const candidate of candidates) {
     const varName = await checkEntrypoint(workPath, candidate);
     if (varName) {
-      (0, import_build_utils7.debug)(`Detected Python entrypoint: ${candidate} (variable: ${varName})`);
+      (0, import_build_utils8.debug)(`Detected Python entrypoint: ${candidate} (variable: ${varName})`);
       return { entrypoint: candidate, variableName: varName };
     }
   }
@@ -5086,7 +5154,7 @@ async function checkDjangoManage(workPath) {
     const content = await import_fs6.default.promises.readFile(managePath, "utf-8");
     if (!content.includes("DJANGO_SETTINGS_MODULE"))
       return false;
-    (0, import_build_utils7.debug)(`Found Django manage.py with DJANGO_SETTINGS_MODULE at ${workPath}`);
+    (0, import_build_utils8.debug)(`Found Django manage.py with DJANGO_SETTINGS_MODULE at ${workPath}`);
     return true;
   } catch {
     return false;
@@ -5102,55 +5170,78 @@ async function getSubdirectories(workPath) {
     return [];
   }
 }
-async function detectGenericPythonEntrypoint(workPath, configuredEntrypoint) {
-  const entry = configuredEntrypoint.endsWith(".py") ? configuredEntrypoint : `${configuredEntrypoint}.py`;
+function makeDetectError(framework) {
+  const searchedList = PYTHON_CANDIDATE_ENTRYPOINTS.join(", ");
+  return new import_build_utils7.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`,
+    action: "Learn More"
+  });
+}
+async function detectGenericPythonEntrypoint(workPath) {
   try {
-    const varName = await checkEntrypoint(workPath, entry);
-    if (varName) {
-      (0, import_build_utils7.debug)(`Using configured Python entrypoint: ${entry}`);
-      return { entrypoint: { entrypoint: entry, variableName: varName } };
-    }
     const found = await findValidEntrypoint(
       workPath,
       PYTHON_CANDIDATE_ENTRYPOINTS
     );
     return found ? { entrypoint: found } : null;
   } catch {
-    (0, import_build_utils7.debug)("Failed to discover Python entrypoint");
+    (0, import_build_utils8.debug)("Failed to discover Python entrypoint");
     return null;
   }
 }
-async function detectDjangoPythonEntrypoint(workPath, configuredEntrypoint) {
-  const entry = configuredEntrypoint.endsWith(".py") ? configuredEntrypoint : `${configuredEntrypoint}.py`;
+async function detectDjangoPythonEntrypoint(workPath) {
   try {
-    const varName = await checkEntrypoint(workPath, entry);
-    if (varName) {
-      (0, import_build_utils7.debug)(`Using configured Python entrypoint: ${entry}`);
-      return { entrypoint: { entrypoint: entry, variableName: varName } };
-    }
     const subdirs = await getSubdirectories(workPath);
     const rootDirs = ["", ...subdirs];
     for (const rootDir of rootDirs) {
       const currPath = (0, import_path8.join)(workPath, rootDir);
       const isDjango = await checkDjangoManage(currPath);
       if (isDjango) {
-        return { baseDir: rootDir };
+        return { baseDir: rootDir, error: makeDetectError("django") };
       }
     }
     const candidates = getCandidateEntrypointsInDirs(rootDirs);
     const found = await findValidEntrypoint(workPath, candidates);
     return found ? { entrypoint: found } : null;
   } catch {
-    (0, import_build_utils7.debug)("Failed to discover Django Python entrypoint");
+    (0, import_build_utils8.debug)("Failed to discover Django Python entrypoint");
     return null;
   }
 }
-async function detectPythonEntrypoint(framework, workPath, configuredEntrypoint) {
-  const result = framework === "django" ? await detectDjangoPythonEntrypoint(workPath, configuredEntrypoint) : await detectGenericPythonEntrypoint(workPath, configuredEntrypoint);
+async function detectPythonEntrypoint(framework, workPath, configuredEntrypoint, service) {
+  if (configuredEntrypoint) {
+    const entrypoint = configuredEntrypoint.endsWith(".py") ? configuredEntrypoint : `${configuredEntrypoint}.py`;
+    let varName = await checkEntrypoint(workPath, entrypoint);
+    if (!varName) {
+      const isSpecialService = service?.type === "cron" || service?.type === "worker";
+      if (isSpecialService) {
+        varName = "app";
+      }
+    }
+    if (varName) {
+      (0, import_build_utils8.debug)(`Using configured Python entrypoint: ${entrypoint}`);
+      return { entrypoint: { entrypoint, variableName: varName } };
+    } else {
+      return {
+        error: new import_build_utils7.NowBuildError({
+          code: "PYTHON_ENTRYPOINT_NOT_FOUND",
+          message: `Could not find a top-level "app", "application", or "handler" in "${entrypoint}".`,
+          link: "https://vercel.com/docs/functions/serverless-functions/runtimes/python",
+          action: "Learn More"
+        })
+      };
+    }
+  }
+  if (!framework) {
+    return null;
+  }
+  const result = framework === "django" ? await detectDjangoPythonEntrypoint(workPath) : await detectGenericPythonEntrypoint(workPath);
   if (result)
     return result;
   const pyprojectEntry = await getPyprojectEntrypoint(workPath);
-  return pyprojectEntry ? { entrypoint: pyprojectEntry } : null;
+  return pyprojectEntry ? { entrypoint: pyprojectEntry } : { error: makeDetectError(framework) };
 }
 
 // src/start-dev-server.ts
@@ -5240,7 +5331,7 @@ async function syncDependencies({
   let { manifestPath } = installInfo;
   const manifest = pythonPackage.manifest;
   if (!manifestType || !manifestPath) {
-    (0, import_build_utils9.debug)("No Python project manifest found, skipping dependency sync");
+    (0, import_build_utils10.debug)("No Python project manifest found, skipping dependency sync");
     return;
   }
   if (manifest?.origin && manifestType === "pyproject.toml") {
@@ -5250,7 +5341,7 @@ async function syncDependencies({
     const content = (0, import_python_analysis6.stringifyManifest)(manifest.data);
     (0, import_fs7.writeFileSync)(tempPyproject, content, "utf8");
     manifestPath = tempPyproject;
-    (0, import_build_utils9.debug)(
+    (0, import_build_utils10.debug)(
       `Wrote converted ${manifest.origin.kind} manifest to ${tempPyproject}`
     );
   }
@@ -5283,7 +5374,7 @@ async function syncDependencies({
     for (const [channel, chunk] of captured) {
       (channel === "stdout" ? writeOut : writeErr)(chunk.toString());
     }
-    throw new import_build_utils9.NowBuildError({
+    throw new import_build_utils10.NowBuildError({
       code: "PYTHON_DEPENDENCY_SYNC_FAILED",
       message: `Failed to install Python dependencies from ${manifestType}: ${err instanceof Error ? err.message : String(err)}`
     });
@@ -5305,7 +5396,7 @@ async function runSync({
   switch (manifestType) {
     case "uv.lock": {
       if (!uvPath) {
-        throw new import_build_utils9.NowBuildError({
+        throw new import_build_utils10.NowBuildError({
           code: "PYTHON_DEPENDENCY_SYNC_FAILED",
           message: "uv is required to install dependencies from uv.lock.",
           link: "https://docs.astral.sh/uv/getting-started/installation/",
@@ -5327,11 +5418,11 @@ async function runSync({
       break;
     }
     default:
-      (0, import_build_utils9.debug)(`Unknown manifest type: ${manifestType}`);
+      (0, import_build_utils10.debug)(`Unknown manifest type: ${manifestType}`);
       return;
   }
   await new Promise((resolve3, reject) => {
-    (0, import_build_utils9.debug)(`Running "${spawnCmd} ${spawnArgs.join(" ")}" in ${projectDir}...`);
+    (0, import_build_utils10.debug)(`Running "${spawnCmd} ${spawnArgs.join(" ")}" in ${projectDir}...`);
     const child = (0, import_child_process2.spawn)(spawnCmd, spawnArgs, {
       cwd: projectDir,
       env: getProtectedUvEnv(env),
@@ -5418,13 +5509,13 @@ async function doInstallVercelRuntime({
       `vercel_runtime-${VERCEL_RUNTIME_VERSION}.dist-info`
     );
     if ((0, import_fs7.existsSync)(distInfo)) {
-      (0, import_build_utils9.debug)(
+      (0, import_build_utils10.debug)(
         `vercel-runtime ${VERCEL_RUNTIME_VERSION} already installed, skipping`
       );
       return;
     }
   }
-  (0, import_build_utils9.debug)(
+  (0, import_build_utils10.debug)(
     `Installing vercel-runtime into ${targetDir} (type: ${isLocalDev ? "local" : "pypi"}, source: ${runtimeDep})`
   );
   const pip = uvPath ? { cmd: uvPath, prefix: ["pip", "install"] } : { cmd: pythonBin, prefix: ["-m", "pip", "install"] };
@@ -5439,14 +5530,14 @@ async function doInstallVercelRuntime({
       if (onStdout) {
         onStdout(data);
       } else {
-        (0, import_build_utils9.debug)(data.toString());
+        (0, import_build_utils10.debug)(data.toString());
       }
     });
     child.stderr?.on("data", (data) => {
       if (onStderr) {
         onStderr(data);
       } else {
-        (0, import_build_utils9.debug)(data.toString());
+        (0, import_build_utils10.debug)(data.toString());
       }
     });
     child.on("error", reject);
@@ -5514,13 +5605,13 @@ async function doInstallVercelWorkers({
       `vercel_workers-${VERCEL_WORKERS_VERSION}.dist-info`
     );
     if ((0, import_fs7.existsSync)(distInfo)) {
-      (0, import_build_utils9.debug)(
+      (0, import_build_utils10.debug)(
         `vercel-workers ${VERCEL_WORKERS_VERSION} already installed, skipping`
       );
       return;
     }
   }
-  (0, import_build_utils9.debug)(
+  (0, import_build_utils10.debug)(
     `Installing vercel-workers into ${targetDir} (type: ${isLocalDev ? "local" : "pypi"}, source: ${workersDep})`
   );
   const pip = uvPath ? { cmd: uvPath, prefix: ["pip", "install"] } : { cmd: pythonBin, prefix: ["-m", "pip", "install"] };
@@ -5535,14 +5626,14 @@ async function doInstallVercelWorkers({
       if (onStdout) {
         onStdout(data);
       } else {
-        (0, import_build_utils9.debug)(data.toString());
+        (0, import_build_utils10.debug)(data.toString());
       }
     });
     child.stderr?.on("data", (data) => {
       if (onStderr) {
         onStderr(data);
       } else {
-        (0, import_build_utils9.debug)(data.toString());
+        (0, import_build_utils10.debug)(data.toString());
       }
     });
     child.on("error", reject);
@@ -5572,12 +5663,12 @@ function installGlobalCleanupHandlers() {
       try {
         process.kill(info.pid, "SIGTERM");
       } catch (err) {
-        (0, import_build_utils9.debug)(`Error sending SIGTERM to ${info.pid}: ${err}`);
+        (0, import_build_utils10.debug)(`Error sending SIGTERM to ${info.pid}: ${err}`);
       }
       try {
         process.kill(info.pid, "SIGKILL");
       } catch (err) {
-        (0, import_build_utils9.debug)(`Error sending SIGKILL to ${info.pid}: ${err}`);
+        (0, import_build_utils10.debug)(`Error sending SIGKILL to ${info.pid}: ${err}`);
       }
       PERSISTENT_SERVERS.delete(key);
     }
@@ -5585,7 +5676,7 @@ function installGlobalCleanupHandlers() {
       try {
         restoreWarnings();
       } catch (err) {
-        (0, import_build_utils9.debug)(`Error restoring warnings: ${err}`);
+        (0, import_build_utils10.debug)(`Error restoring warnings: ${err}`);
       }
       restoreWarnings = null;
     }
@@ -5622,26 +5713,31 @@ function createDevShim(workPath, entry, modulePath, serviceName, framework, vari
     const template = (0, import_fs7.readFileSync)(templatePath, "utf8");
     const shimSource = template.replace(/__VC_DEV_MODULE_NAME__/g, qualifiedModule).replace(/__VC_DEV_ENTRY_ABS__/g, entryAbs).replace(/__VC_DEV_FRAMEWORK__/g, framework).replace(/__VC_DEV_VARIABLE_NAME__/g, variableName);
     (0, import_fs7.writeFileSync)(shimPath, shimSource, "utf8");
-    (0, import_build_utils9.debug)(`Prepared Python dev shim at ${shimPath}`);
+    (0, import_build_utils10.debug)(`Prepared Python dev shim at ${shimPath}`);
     return {
       module: DEV_SHIM_MODULE,
       extraPythonPath,
       shimDir: vercelPythonDir
     };
   } catch (err) {
-    (0, import_build_utils9.debug)(`Failed to prepare dev shim: ${err?.message || err}`);
+    (0, import_build_utils10.debug)(`Failed to prepare dev shim: ${err?.message || err}`);
     return null;
   }
 }
 async function getMultiServicePythonRunner(workPath, env, systemPython, uvPath) {
   const { pythonCmd, venvRoot } = useVirtualEnv(workPath, env, systemPython);
   if (venvRoot) {
-    (0, import_build_utils9.debug)(`Using existing virtualenv at ${venvRoot} for multi-service dev`);
+    (0, import_build_utils10.debug)(`Using existing virtualenv at ${venvRoot} for multi-service dev`);
     return { command: pythonCmd, args: [] };
   }
   const venvPath = (0, import_path9.join)(workPath, ".venv");
-  await ensureVenv({ pythonPath: systemPython, venvPath, uvPath, quiet: true });
-  (0, import_build_utils9.debug)(`Created virtualenv at ${venvPath} for multi-service dev`);
+  await ensureVenv({
+    pythonVersion: { pythonPath: systemPython },
+    venvPath,
+    uvPath,
+    quiet: true
+  });
+  (0, import_build_utils10.debug)(`Created virtualenv at ${venvPath} for multi-service dev`);
   const pythonBin = getVenvPythonBin(venvPath);
   const binDir = getVenvBinDir(venvPath);
   env.VIRTUAL_ENV = venvPath;
@@ -5654,11 +5750,12 @@ var startDevServer = async (opts) => {
     workPath,
     meta = {},
     config,
+    service,
     onStdout,
     onStderr
   } = opts;
   const framework = config?.framework;
-  const serviceName = typeof meta.serviceName === "string" ? meta.serviceName : void 0;
+  const serviceName = service?.name ?? (typeof meta.serviceName === "string" ? meta.serviceName : void 0);
   const serverKey = serviceName ? `${workPath}::${framework}::${serviceName}` : `${workPath}::${framework}`;
   const existing = PERSISTENT_SERVERS.get(serverKey);
   if (existing) {
@@ -5688,37 +5785,34 @@ var startDevServer = async (opts) => {
     restoreWarnings = silenceNodeWarnings();
   installGlobalCleanupHandlers();
   const env = { ...process.env, ...meta.env || {} };
-  const serviceType = env.VERCEL_SERVICE_TYPE;
+  const entrypoint = rawEntrypoint === "<detect>" ? void 0 : rawEntrypoint;
   let resolved;
-  if ((serviceType === "cron" || serviceType === "worker") && rawEntrypoint?.endsWith(".py")) {
-    resolved = { entrypoint: rawEntrypoint, variableName: "app" };
+  const detected = await detectPythonEntrypoint(
+    framework,
+    workPath,
+    entrypoint,
+    service
+  );
+  if (detected?.entrypoint) {
+    resolved = detected.entrypoint;
   } else {
-    const detected = await detectPythonEntrypoint(
-      framework,
+    const hookResult = await runFrameworkHook(framework, {
+      pythonEnv: env,
+      projectDir: (0, import_path9.join)(workPath, detected?.baseDir ?? ""),
       workPath,
-      rawEntrypoint
-    );
-    if (detected?.entrypoint) {
-      resolved = detected.entrypoint;
-    } else {
-      const hookResult = await runFrameworkHook(framework, {
-        pythonEnv: env,
-        projectDir: (0, import_path9.join)(workPath, detected?.baseDir ?? ""),
-        workPath,
-        entrypoint: rawEntrypoint,
-        detected: detected ?? void 0
-      });
-      resolved = hookResult?.entrypoint;
-    }
-    if (!resolved) {
-      const searched = PYTHON_CANDIDATE_ENTRYPOINTS.join(", ");
-      throw new import_build_utils9.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"
-      });
+      entrypoint,
+      detected: detected ?? void 0
+    });
+    resolved = hookResult?.entrypoint;
+  }
+  if (!resolved) {
+    if (detected?.error) {
+      throw detected.error;
     }
+    throw new import_build_utils10.NowBuildError({
+      code: "PYTHON_ENTRYPOINT_NOT_FOUND",
+      message: "No Python entrypoint could be detected. Please specify an entrypoint file."
+    });
   }
   const { entrypoint: entry, variableName } = resolved;
   const modulePath = entry.replace(/\.py$/i, "").replace(/[\\/]/g, ".");
@@ -5744,7 +5838,7 @@ var startDevServer = async (opts) => {
       const yellow = "\x1B[33m";
       const white = "\x1B[1m";
       const reset = "\x1B[0m";
-      throw new import_build_utils9.NowBuildError({
+      throw new import_build_utils10.NowBuildError({
         code: "PYTHON_EXTERNAL_VENV_DETECTED",
         message: `Detected activated venv at ${yellow}${venv}${reset}, ${white}vercel dev${reset} manages virtual environments automatically.
 Run ${white}deactivate${reset} and try again.`
@@ -5761,11 +5855,11 @@ Run ${white}deactivate${reset} and try again.`
       );
       spawnCommand = runner.command;
       spawnArgsPrefix = runner.args;
-      (0, import_build_utils9.debug)(
+      (0, import_build_utils10.debug)(
         `Multi-service Python runner: ${spawnCommand} ${spawnArgsPrefix.join(" ")}`
       );
     } else if (venv) {
-      (0, import_build_utils9.debug)(`Running in virtualenv at ${venv}`);
+      (0, import_build_utils10.debug)(`Running in virtualenv at ${venv}`);
     } else {
       const { pythonCmd: venvPythonCmd, venvRoot } = useVirtualEnv(
         workPath,
@@ -5774,9 +5868,9 @@ Run ${white}deactivate${reset} and try again.`
       );
       spawnCommand = venvPythonCmd;
       if (venvRoot) {
-        (0, import_build_utils9.debug)(`Using virtualenv at ${venvRoot}`);
+        (0, import_build_utils10.debug)(`Using virtualenv at ${venvRoot}`);
       } else {
-        (0, import_build_utils9.debug)("No virtualenv found");
+        (0, import_build_utils10.debug)("No virtualenv found");
         try {
           const yellow = "\x1B[33m";
           const reset = "\x1B[0m";
@@ -5857,7 +5951,7 @@ If you are using a virtual environment, activate it before running "vercel dev",
     const moduleToRun = devShim?.module || modulePath;
     const pythonArgs = ["-u", "-m", moduleToRun];
     const argv = [...spawnArgsPrefix, ...pythonArgs];
-    (0, import_build_utils9.debug)(
+    (0, import_build_utils10.debug)(
       `Starting Python dev server (${framework}): ${spawnCommand} ${argv.join(" ")} [PORT=${port}]`
     );
     if (process.stdout.columns) {
@@ -5911,7 +6005,7 @@ If you are using a virtual environment, activate it before running "vercel dev",
 };
 
 // src/quirks/index.ts
-var import_build_utils12 = require("@vercel/build-utils");
+var import_build_utils13 = require("@vercel/build-utils");
 var import_python_analysis8 = require("@vercel/python-analysis");
 
 // src/quirks/matplotlib.ts
@@ -5927,7 +6021,7 @@ var matplotlibQuirk = {
 // src/quirks/litellm.ts
 var import_fs8 = __toESM(require("fs"));
 var import_path10 = require("path");
-var import_build_utils10 = require("@vercel/build-utils");
+var import_build_utils11 = require("@vercel/build-utils");
 var LAMBDA_ROOT = "/var/task";
 var CONFIG_CANDIDATES = [
   "litellm_config.yaml",
@@ -5962,24 +6056,24 @@ var litellmQuirk = {
       );
       try {
         await import_fs8.default.promises.access(schemaPath);
-        (0, import_build_utils10.debug)(`LiteLLM quirk: found schema at ${schemaPath}`);
+        (0, import_build_utils11.debug)(`LiteLLM quirk: found schema at ${schemaPath}`);
         buildEnv.PRISMA_SCHEMA_PATH = schemaPath;
         break;
       } catch {
       }
     }
     if (!buildEnv.PRISMA_SCHEMA_PATH) {
-      (0, import_build_utils10.debug)("LiteLLM quirk: schema.prisma not found in any site-packages");
+      (0, import_build_utils11.debug)("LiteLLM quirk: schema.prisma not found in any site-packages");
     }
     if (!process.env.CONFIG_FILE_PATH) {
       const configName = await findConfigFile(ctx.workPath);
       if (configName) {
-        (0, import_build_utils10.debug)(`LiteLLM quirk: found config at ${configName}`);
+        (0, import_build_utils11.debug)(`LiteLLM quirk: found config at ${configName}`);
         buildEnv.CONFIG_FILE_PATH = (0, import_path10.join)(ctx.workPath, configName);
         env.CONFIG_FILE_PATH = (0, import_path10.join)(LAMBDA_ROOT, configName);
       }
     } else {
-      (0, import_build_utils10.debug)(
+      (0, import_build_utils11.debug)(
         `LiteLLM quirk: CONFIG_FILE_PATH already set to ${process.env.CONFIG_FILE_PATH}`
       );
     }
@@ -5991,7 +6085,7 @@ var litellmQuirk = {
 var import_fs9 = __toESM(require("fs"));
 var import_path11 = require("path");
 var import_execa4 = __toESM(require_execa());
-var import_build_utils11 = require("@vercel/build-utils");
+var import_build_utils12 = require("@vercel/build-utils");
 var import_python_analysis7 = require("@vercel/python-analysis");
 function execErrorMessage(err) {
   if (err != null && typeof err === "object" && "stderr" in err) {
@@ -6034,7 +6128,7 @@ async function findUserSchema(workPath) {
       await import_fs9.default.promises.access(resolved);
       return resolved;
     } catch {
-      (0, import_build_utils11.debug)(`PRISMA_SCHEMA_PATH=${envPath} not found at ${resolved}`);
+      (0, import_build_utils12.debug)(`PRISMA_SCHEMA_PATH=${envPath} not found at ${resolved}`);
       return null;
     }
   }
@@ -6138,7 +6232,7 @@ var prismaQuirk = {
       dummySchemaPath,
       buildDummySchema(generatedDir)
     );
-    (0, import_build_utils11.debug)(`Running prisma generate (dummy) with cache dir: ${cacheDir}`);
+    (0, import_build_utils12.debug)(`Running prisma generate (dummy) with cache dir: ${cacheDir}`);
     try {
       const dummyResult = await (0, import_execa4.default)(
         pythonPath,
@@ -6150,11 +6244,11 @@ var prismaQuirk = {
         }
       );
       if (dummyResult.stdout)
-        (0, import_build_utils11.debug)(`prisma generate (dummy) stdout: ${dummyResult.stdout}`);
+        (0, import_build_utils12.debug)(`prisma generate (dummy) stdout: ${dummyResult.stdout}`);
       if (dummyResult.stderr)
-        (0, import_build_utils11.debug)(`prisma generate (dummy) stderr: ${dummyResult.stderr}`);
+        (0, import_build_utils12.debug)(`prisma generate (dummy) stderr: ${dummyResult.stderr}`);
     } catch (err) {
-      throw new import_build_utils11.NowBuildError({
+      throw new import_build_utils12.NowBuildError({
         code: "PRISMA_GENERATE_FAILED",
         message: `Prisma engine download failed during \`prisma generate\`. Check that your prisma version is compatible with this Python version.
 ` + execErrorMessage(err)
@@ -6173,22 +6267,22 @@ var prismaQuirk = {
         const destPath = (0, import_path11.join)(cacheDir, runtimeName);
         try {
           await import_fs9.default.promises.access(destPath);
-          (0, import_build_utils11.debug)(`Engine binary: ${runtimeName} already exists, skipping`);
+          (0, import_build_utils12.debug)(`Engine binary: ${runtimeName} already exists, skipping`);
         } catch {
-          (0, import_build_utils11.debug)(`Engine binary: copying ${entry} -> ${runtimeName}`);
+          (0, import_build_utils12.debug)(`Engine binary: copying ${entry} -> ${runtimeName}`);
           await import_fs9.default.promises.copyFile(srcPath, destPath);
         }
         engineCopied = true;
       }
     } catch (err) {
-      throw new import_build_utils11.NowBuildError({
+      throw new import_build_utils12.NowBuildError({
         code: "PRISMA_ENGINE_NOT_FOUND",
         message: `could not read Prisma engine directory "${nodeModulesDir}". This may indicate an incompatible prisma version.
 ` + (err instanceof Error ? err.message : String(err))
       });
     }
     if (!engineCopied) {
-      throw new import_build_utils11.NowBuildError({
+      throw new import_build_utils12.NowBuildError({
         code: "PRISMA_ENGINE_NOT_FOUND",
         message: `could not find engine binary matching "${srcBinaryPrefix}*" in "${nodeModulesDir}". This may indicate an incompatible prisma version or an unsupported platform (${process.arch}).`
       });
@@ -6215,14 +6309,14 @@ echo "OpenSSL ${RUNTIME_OPENSSL_VERSION}.0 1 Jan 2024 (Library: OpenSSL ${RUNTIM
           pythonEnv
         );
         if (clientAlreadyGenerated) {
-          (0, import_build_utils11.debug)(
+          (0, import_build_utils12.debug)(
             "Prisma quirk: client already generated, skipping user schema generate"
           );
           shouldGenerate = false;
         }
       }
       if (shouldGenerate) {
-        (0, import_build_utils11.debug)(`Running prisma generate with user schema: ${userSchema}`);
+        (0, import_build_utils12.debug)(`Running prisma generate with user schema: ${userSchema}`);
         try {
           const userResult = await (0, import_execa4.default)(
             pythonPath,
@@ -6234,11 +6328,11 @@ echo "OpenSSL ${RUNTIME_OPENSSL_VERSION}.0 1 Jan 2024 (Library: OpenSSL ${RUNTIM
             }
           );
           if (userResult.stdout)
-            (0, import_build_utils11.debug)(`prisma generate stdout: ${userResult.stdout}`);
+            (0, import_build_utils12.debug)(`prisma generate stdout: ${userResult.stdout}`);
           if (userResult.stderr)
-            (0, import_build_utils11.debug)(`prisma generate stderr: ${userResult.stderr}`);
+            (0, import_build_utils12.debug)(`prisma generate stderr: ${userResult.stderr}`);
         } catch (err) {
-          throw new import_build_utils11.NowBuildError({
+          throw new import_build_utils12.NowBuildError({
             code: "PRISMA_GENERATE_FAILED",
             message: `\`prisma generate\` failed for schema "${userSchema}".
 ` + execErrorMessage(err)
@@ -6254,7 +6348,7 @@ echo "OpenSSL ${RUNTIME_OPENSSL_VERSION}.0 1 Jan 2024 (Library: OpenSSL ${RUNTIM
       );
       const count = await (0, import_python_analysis7.extendDistRecord)(sitePackages, "prisma", allFiles);
       if (count > 0) {
-        (0, import_build_utils11.debug)(`Appended ${count} entries to prisma RECORD`);
+        (0, import_build_utils12.debug)(`Appended ${count} entries to prisma RECORD`);
       }
     } catch (err) {
       console.warn(
@@ -6348,13 +6442,13 @@ async function runQuirks(ctx) {
       (0, import_python_analysis8.normalizePackageName)(quirk.dependency)
     );
     if (!installed) {
-      (0, import_build_utils12.debug)(`Quirk "${quirk.dependency}": not installed, skipping`);
+      (0, import_build_utils13.debug)(`Quirk "${quirk.dependency}": not installed, skipping`);
     }
     return installed;
   });
   const sorted = toposortQuirks(activated);
   for (const quirk of sorted) {
-    (0, import_build_utils12.debug)(`Quirk "${quirk.dependency}": detected, running fix-up`);
+    (0, import_build_utils13.debug)(`Quirk "${quirk.dependency}": detected, running fix-up`);
     const result = await quirk.run(ctx);
     if (result.env) {
       Object.assign(mergedEnv, result.env);
@@ -6378,31 +6472,30 @@ async function runQuirks(ctx) {
 var import_fs10 = __toESM(require("fs"));
 var import_path12 = require("path");
 var import_execa5 = __toESM(require_execa());
-var import_build_utils13 = require("@vercel/build-utils");
+var import_build_utils14 = require("@vercel/build-utils");
 var scriptPath = (0, import_path12.join)(__dirname, "..", "templates", "vc_django_settings.py");
 var script = import_fs10.default.readFileSync(scriptPath, "utf-8");
 async function getDjangoSettings(projectDir, env) {
-  try {
-    const { stdout } = await (0, import_execa5.default)("python", ["-c", script], {
-      env,
-      cwd: projectDir
-    });
-    const parsed = JSON.parse(stdout);
-    if (!parsed)
-      return null;
-    return {
-      settingsModule: parsed.settings_module,
-      djangoSettings: parsed.django_settings
-    };
-  } catch (err) {
-    (0, import_build_utils13.debug)(`Django hook: failed to discover settings from manage.py: ${err}`);
-    return null;
+  const { stdout } = await (0, import_execa5.default)("python", ["-c", script], {
+    env,
+    cwd: projectDir
+  });
+  const parsed = JSON.parse(stdout);
+  if (!parsed) {
+    throw new Error("manage.py did not return any settings");
   }
+  return {
+    settingsModule: parsed.settings_module,
+    djangoSettings: parsed.django_settings,
+    djangoVersion: parsed.django_version ?? null
+  };
 }
-async function runDjangoCollectStatic(venvPath, workPath, env, outputStaticDir, settingsModule, djangoSettings) {
+async function runDjangoCollectStatic(venvPath, workPath, env, outputStaticDir, settingsModule, djangoSettings, djangoVersion) {
   const pythonPath = getVenvPythonBin(venvPath);
   const storages = djangoSettings["STORAGES"];
-  const storageBackend = storages?.staticfiles?.BACKEND ?? djangoSettings["STATICFILES_STORAGE"] ?? "django.contrib.staticfiles.storage.StaticFilesStorage";
+  const useLegacySetting = !djangoVersion || djangoVersion[0] < 5 || djangoVersion[0] === 5 && djangoVersion[1] < 1;
+  const legacyBackend = useLegacySetting ? djangoSettings["STATICFILES_STORAGE"] : void 0;
+  const storageBackend = storages?.staticfiles?.BACKEND ?? legacyBackend ?? "django.contrib.staticfiles.storage.StaticFilesStorage";
   const staticUrl = djangoSettings["STATIC_URL"] ?? "/static/";
   const staticRoot = djangoSettings["STATIC_ROOT"] != null ? String(djangoSettings["STATIC_ROOT"]) : null;
   const whitenoiseUseFinders = djangoSettings["WHITENOISE_USE_FINDERS"] === true;
@@ -6471,7 +6564,7 @@ async function runDjangoCollectStatic(venvPath, workPath, env, outputStaticDir,
     await import_fs10.default.promises.mkdir(resolvedStaticRoot, { recursive: true });
     await import_fs10.default.promises.copyFile(manifestSrc, manifestDest);
     manifestRelPath = (0, import_path12.relative)(workPath, manifestDest);
-    (0, import_build_utils13.debug)(`Copied staticfiles.json to ${manifestDest} for Lambda bundle`);
+    (0, import_build_utils14.debug)(`Copied staticfiles.json to ${manifestDest} for Lambda bundle`);
   }
   return {
     staticSourceDirs,
@@ -6498,14 +6591,31 @@ var frameworkHooks = {
     detected
   }) => {
     if (detected?.baseDir === void 0) {
-      (0, import_build_utils14.debug)("Django hook: no manage.py detected, skipping");
+      (0, import_build_utils15.debug)("Django hook: no manage.py detected, skipping");
       return;
     }
-    const settingsResult = await getDjangoSettings(projectDir, pythonEnv);
-    (0, import_build_utils14.debug)(`Django settings: ${JSON.stringify(settingsResult)}`);
-    if (!settingsResult)
-      return;
-    const { djangoSettings, settingsModule } = settingsResult;
+    let settingsResult;
+    try {
+      settingsResult = await getDjangoSettings(projectDir, pythonEnv);
+    } catch (err) {
+      let detail;
+      if (err?.code === "ENOENT") {
+        detail = `command not found: python
+Hint: activate a venv or run with \`uv run vercel dev\``;
+      } else {
+        detail = err?.stderr || err?.message || String(err);
+      }
+      throw new import_build_utils15.NowBuildError({
+        code: "DJANGO_SETTINGS_FAILED",
+        message: `Failed to read Django application settings from ${projectDir}/manage.py:
+${detail}`
+      });
+    }
+    (0, import_build_utils15.debug)(`Django settings: ${JSON.stringify(settingsResult)}`);
+    const { djangoSettings, settingsModule, djangoVersion } = settingsResult;
+    if (djangoVersion) {
+      console.log(`Django ${djangoVersion.join(".")} detected`);
+    }
     let resolvedEntrypoint;
     const baseDir = detected?.baseDir ?? "";
     const asgiApp = djangoSettings["ASGI_APPLICATION"];
@@ -6514,7 +6624,7 @@ var frameworkHooks = {
       const variableName = parts.at(-1);
       const rel = `${parts.slice(0, -1).join("/")}.py`;
       const ep = baseDir ? `${baseDir}/${rel}` : rel;
-      (0, import_build_utils14.debug)(`Django hook: ASGI entrypoint: ${ep} (variable: ${variableName})`);
+      (0, import_build_utils15.debug)(`Django hook: ASGI entrypoint: ${ep} (variable: ${variableName})`);
       resolvedEntrypoint = { entrypoint: ep, variableName };
     } else {
       const wsgiApp = djangoSettings["WSGI_APPLICATION"];
@@ -6523,7 +6633,7 @@ var frameworkHooks = {
         const variableName = parts.at(-1);
         const rel = `${parts.slice(0, -1).join("/")}.py`;
         const ep = baseDir ? `${baseDir}/${rel}` : rel;
-        (0, import_build_utils14.debug)(
+        (0, import_build_utils15.debug)(
           `Django hook: WSGI entrypoint: ${ep} (variable: ${variableName})`
         );
         resolvedEntrypoint = { entrypoint: ep, variableName };
@@ -6538,7 +6648,8 @@ var frameworkHooks = {
         pythonEnv,
         outputStaticDir,
         settingsModule,
-        djangoSettings
+        djangoSettings,
+        djangoVersion
       );
     }
     return { entrypoint: resolvedEntrypoint, djangoStatic };
@@ -6550,14 +6661,14 @@ async function downloadFilesInWorkPath({
   files,
   meta = {}
 }) {
-  (0, import_build_utils14.debug)("Downloading user files...");
-  let downloadedFiles = await (0, import_build_utils14.download)(files, workPath, meta);
-  if (meta.isDev) {
+  (0, import_build_utils15.debug)("Downloading user files...");
+  let downloadedFiles = await (0, import_build_utils15.download)(files, workPath, meta);
+  if (meta.isDev && entrypoint) {
     const { devCacheDir = (0, import_path13.join)(workPath, ".now", "cache") } = meta;
     const cacheKey = (0, import_path13.basename)(entrypoint).replace(/\./g, "_");
     const destCache = (0, import_path13.join)(devCacheDir, cacheKey);
-    await (0, import_build_utils14.download)(downloadedFiles, destCache);
-    downloadedFiles = await (0, import_build_utils14.glob)("**", destCache);
+    await (0, import_build_utils15.download)(downloadedFiles, destCache);
+    downloadedFiles = await (0, import_build_utils15.glob)("**", destCache);
     workPath = destCache;
   }
   return workPath;
@@ -6566,19 +6677,20 @@ var build = async ({
   workPath,
   repoRootPath,
   files: originalFiles,
-  entrypoint,
+  entrypoint: rawEntrypoint,
   meta = {},
   config,
   span: parentSpan,
   service
 }) => {
-  const builderSpan = parentSpan ?? new import_build_utils14.Span({ name: "vc.builder" });
+  let entrypoint = rawEntrypoint === "<detect>" ? void 0 : rawEntrypoint;
+  const builderSpan = parentSpan ?? new import_build_utils15.Span({ name: "vc.builder" });
   const framework = config?.framework;
   const shouldInstallVercelWorkers = config?.hasWorkerServices === true;
   let spawnEnv;
   let projectInstallCommand;
   let hasCustomCommand = false;
-  (0, import_build_utils14.debug)(`workPath: ${workPath}`);
+  (0, import_build_utils15.debug)(`workPath: ${workPath}`);
   workPath = await downloadFilesInWorkPath({
     workPath,
     files: originalFiles,
@@ -6594,56 +6706,17 @@ var build = async ({
     console.log('Failed to create "setup.cfg" file');
     throw err;
   }
-  let fsFiles = await (0, import_build_utils14.glob)("**", workPath);
   let detected;
-  let entrypointNotFound;
-  if ((0, import_build_utils14.isPythonFramework)(framework) && // XXX: we might want to detect anyway for django!
-  (!fsFiles[entrypoint] || !entrypoint.endsWith(".py"))) {
-    detected = await detectPythonEntrypoint(
-      config.framework,
-      workPath,
-      entrypoint
-    ) ?? void 0;
-    if (detected?.entrypoint) {
-      (0, import_build_utils14.debug)(
-        `Resolved Python entrypoint to "${detected.entrypoint.entrypoint}" (configured "${entrypoint}" not found).`
-      );
-      entrypoint = detected.entrypoint.entrypoint;
-    } else {
-      const searchedList = PYTHON_CANDIDATE_ENTRYPOINTS.join(", ");
-      entrypointNotFound = new import_build_utils14.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`,
-        action: "Learn More"
-      });
-    }
-  }
-  if (!detected?.entrypoint && entrypoint.endsWith(".py") && fsFiles[entrypoint]) {
-    const content = await import_fs11.default.promises.readFile(
-      (0, import_path13.join)(workPath, entrypoint),
-      "utf-8"
-    );
-    let varName = await (0, import_python_analysis9.findAppOrHandler)(content);
-    if (!varName) {
-      const isSpecialService = service?.type === "cron" || service?.type === "worker";
-      if (isSpecialService) {
-        varName = "app";
-      } else if (!varName) {
-        throw new import_build_utils14.NowBuildError({
-          code: "PYTHON_ENTRYPOINT_NOT_FOUND",
-          message: `Could not find a top-level "app", "application", or "handler" in "${entrypoint}".`,
-          link: "https://vercel.com/docs/functions/serverless-functions/runtimes/python",
-          action: "Learn More"
-        });
-      }
-    }
-    detected = { entrypoint: { entrypoint, variableName: varName } };
-  }
-  if (entrypointNotFound && detected?.baseDir === void 0) {
-    throw entrypointNotFound;
+  detected = await detectPythonEntrypoint(
+    config.framework,
+    workPath,
+    entrypoint,
+    service
+  ) ?? void 0;
+  if (detected?.error && detected?.baseDir === void 0) {
+    throw detected?.error;
   }
-  const entryDirectory = detected?.baseDir ?? (0, import_path13.dirname)(entrypoint);
+  const entryDirectory = detected?.baseDir ?? (entrypoint ? (0, import_path13.dirname)(entrypoint) : ".");
   const entrypointAbsDir = (0, import_path13.join)(workPath, entryDirectory);
   const rootDir = repoRootPath ?? workPath;
   const pythonPackage = await builderSpan.child("vc.builder.python.discover").trace(
@@ -6674,22 +6747,30 @@ var build = async ({
 `
     );
   }
-  fsFiles = await (0, import_build_utils14.glob)("**", workPath);
   const venvPath = service?.name ? (0, import_path13.join)(workPath, ".vercel", "python", "services", service.name, ".venv") : (0, import_path13.join)(workPath, ".vercel", "python", ".venv");
+  const uvCacheDir = getUvCacheDir(workPath);
+  const hasCachedVenv = import_fs11.default.existsSync((0, import_path13.join)(venvPath, "pyvenv.cfg"));
+  const hasCachedUv = import_fs11.default.existsSync(uvCacheDir);
+  if (hasCachedVenv || hasCachedUv) {
+    (0, import_build_utils15.debug)(
+      `Build cache detected: venv=${hasCachedVenv}, uv-cache=${hasCachedUv}`
+    );
+  }
   await builderSpan.child("vc.builder.python.venv").trace(async () => {
     await ensureVenv({
-      pythonPath: pythonVersion.pythonPath,
-      venvPath
+      pythonVersion,
+      venvPath,
+      uvCacheDir
     });
   });
-  if ((0, import_build_utils14.isPythonFramework)(framework)) {
+  if ((0, import_build_utils15.isPythonFramework)(framework)) {
     const {
       cliType,
       lockfileVersion,
       packageJsonPackageManager,
       turboSupportsCorepackHome
-    } = await (0, import_build_utils14.scanParentDirs)(workPath, true);
-    spawnEnv = (0, import_build_utils14.getEnvForPackageManager)({
+    } = await (0, import_build_utils15.scanParentDirs)(workPath, true);
+    spawnEnv = (0, import_build_utils15.getEnvForPackageManager)({
       cliType,
       lockfileVersion,
       packageJsonPackageManager,
@@ -6708,13 +6789,13 @@ 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);
-    uv = new UvRunner(uvPath);
+    uv = new UvRunner(uvPath, uvCacheDir);
     const uvVersionOutput = (0, import_child_process3.execSync)(`${uvPath} --version`, {
       encoding: "utf8"
     }).trim();
@@ -6728,32 +6809,42 @@ var build = async ({
   let uvLockPath = null;
   let uvProjectDir = null;
   let projectName;
-  await builderSpan.child(import_build_utils14.BUILDER_INSTALLER_STEP, {
+  await builderSpan.child(import_build_utils15.BUILDER_INSTALLER_STEP, {
     installCommand: projectInstallCommand || void 0
   }).trace(async () => {
     if (projectInstallCommand) {
+      await import_fs11.default.promises.rm(venvPath, { recursive: true, force: true });
+      await ensureVenv({
+        pythonVersion,
+        venvPath,
+        uvCacheDir,
+        quiet: true
+      });
       console.log(
         `Running "install" command: \`${projectInstallCommand}\`...`
       );
-      await (0, import_build_utils14.execCommand)(projectInstallCommand, {
+      await (0, import_build_utils15.execCommand)(projectInstallCommand, {
         env: pythonEnv,
         cwd: workPath
       });
       assumeDepsInstalled = true;
       hasCustomCommand = true;
     } else {
-      assumeDepsInstalled = await runPyprojectScript(
+      const hasCustomScript = await runPyprojectScript(
         workPath,
         ["vercel-install", "now-install", "install"],
         pythonEnv,
         /* useUserVirtualEnv */
         false
       );
-      if (assumeDepsInstalled) {
+      if (hasCustomScript) {
+        assumeDepsInstalled = true;
         hasCustomCommand = true;
       }
     }
     if (!assumeDepsInstalled) {
+      const lockCacheKey = service?.name ? `uv.lock.${service.name}` : "uv.lock";
+      const cachedLockPath = (0, import_path13.join)(uvCacheDir, lockCacheKey);
       const { projectDir, lockPath, lockFileProvidedByUser } = await ensureUvProject({
         workPath,
         rootDir,
@@ -6761,8 +6852,8 @@ var build = async ({
         pythonPackage,
         pythonVersion: pythonVersionString(pythonVersion),
         uv,
-        generateLockFile: true,
-        requireBinaryWheels: false
+        requireBinaryWheels: false,
+        cachedLockPath
       });
       uvLockPath = lockPath;
       uvProjectDir = projectDir;
@@ -6773,17 +6864,21 @@ var build = async ({
         frozen: lockFileProvidedByUser,
         locked: !lockFileProvidedByUser
       });
+      if (lockPath && import_fs11.default.existsSync(lockPath)) {
+        await import_fs11.default.promises.mkdir(uvCacheDir, { recursive: true });
+        await import_fs11.default.promises.copyFile(lockPath, cachedLockPath);
+      }
     }
   });
-  if ((0, import_build_utils14.isPythonFramework)(framework)) {
+  if ((0, import_build_utils15.isPythonFramework)(framework)) {
     const projectBuildCommand = config?.projectSettings?.buildCommand ?? // fallback if provided directly on config (some callers set this)
     config?.buildCommand;
-    await builderSpan.child(import_build_utils14.BUILDER_COMPILE_STEP, {
+    await builderSpan.child(import_build_utils15.BUILDER_COMPILE_STEP, {
       buildCommand: projectBuildCommand || void 0
     }).trace(async () => {
       if (projectBuildCommand) {
         console.log(`Running "${projectBuildCommand}"`);
-        await (0, import_build_utils14.execCommand)(projectBuildCommand, {
+        await (0, import_build_utils15.execCommand)(projectBuildCommand, {
           env: pythonEnv,
           cwd: workPath
         });
@@ -6805,16 +6900,19 @@ var build = async ({
     detected
   });
   const resolved = hookResult?.entrypoint ?? detected?.entrypoint;
-  if (entrypointNotFound && resolved) {
-    entrypoint = resolved.entrypoint;
-    entrypointNotFound = void 0;
-  }
-  if (entrypointNotFound) {
-    throw entrypointNotFound;
+  if (!resolved && detected?.error) {
+    throw detected?.error;
+  }
+  entrypoint = resolved?.entrypoint;
+  if (!entrypoint) {
+    throw new import_build_utils15.NowBuildError({
+      code: "PYTHON_ENTRYPOINT_NOT_FOUND",
+      message: "No Python entrypoint could be detected. Please specify an entrypoint file."
+    });
   }
   const djangoStatic = hookResult?.djangoStatic ?? null;
   const runtimeDep = baseEnv.VERCEL_RUNTIME_PYTHON || `vercel-runtime==${VERCEL_RUNTIME_VERSION}`;
-  (0, import_build_utils14.debug)(`Installing ${runtimeDep}`);
+  (0, import_build_utils15.debug)(`Installing ${runtimeDep}`);
   await uv.pip({
     venvPath,
     projectDir: (0, import_path13.join)(workPath, entryDirectory),
@@ -6822,7 +6920,7 @@ var build = async ({
   });
   if (shouldInstallVercelWorkers) {
     const workersDep = baseEnv.VERCEL_WORKERS_PYTHON || `vercel-workers==${VERCEL_WORKERS_VERSION}`;
-    (0, import_build_utils14.debug)(`Installing ${workersDep}`);
+    (0, import_build_utils15.debug)(`Installing ${workersDep}`);
     await uv.pip({
       venvPath,
       projectDir: (0, import_path13.join)(workPath, entryDirectory),
@@ -6833,7 +6931,7 @@ var build = async ({
   if (quirksResult.buildEnv) {
     Object.assign(pythonEnv, quirksResult.buildEnv);
   }
-  (0, import_build_utils14.debug)("Entrypoint is", entrypoint);
+  (0, import_build_utils15.debug)("Entrypoint is", entrypoint);
   const moduleName = entrypoint.replace(/\//g, ".").replace(/\.py$/i, "");
   const handlerFunction = typeof config?.handlerFunction === "string" ? config.handlerFunction : void 0;
   if (handlerFunction) {
@@ -6841,7 +6939,7 @@ var build = async ({
     const source = await import_fs11.default.promises.readFile(entrypointPath, "utf-8");
     const found = await (0, import_python_analysis9.containsTopLevelCallable)(source, handlerFunction);
     if (!found) {
-      throw new import_build_utils14.NowBuildError({
+      throw new import_build_utils15.NowBuildError({
         code: "PYTHON_HANDLER_NOT_FOUND",
         message: `Handler function "${handlerFunction}" not found in ${entrypoint}. Ensure it is defined at the module's top level.`
       });
@@ -6850,7 +6948,7 @@ var build = async ({
   const vendorDir = resolveVendorDir();
   const suffix = meta.isDev && !entrypoint.endsWith(".py") ? ".py" : "";
   const entrypointWithSuffix = `${entrypoint}${suffix}`;
-  (0, import_build_utils14.debug)("Entrypoint with suffix is", entrypointWithSuffix);
+  (0, import_build_utils15.debug)("Entrypoint with suffix is", entrypointWithSuffix);
   const handlerFuncEnvLine = handlerFunction ? `
   "__VC_HANDLER_FUNC_NAME": "${handlerFunction}",` : "";
   const variableName = resolved?.variableName ?? "";
@@ -6911,18 +7009,6 @@ from vercel_runtime.vc_init import vc_handler
     "**/yarn.lock",
     "**/package-lock.json"
   ];
-  if (djangoStatic) {
-    const dirsToExclude = [
-      ...djangoStatic.staticSourceDirs,
-      ...djangoStatic.staticRoot ? [djangoStatic.staticRoot] : []
-    ];
-    for (const absDir of dirsToExclude) {
-      const rel = (0, import_path13.relative)(workPath, absDir);
-      if (!rel.startsWith("..")) {
-        predefinedExcludes.push(`${rel}/**`);
-      }
-    }
-  }
   const lambdaEnv = {};
   lambdaEnv.PYTHONPATH = vendorDir;
   Object.assign(lambdaEnv, quirksResult.env);
@@ -6933,9 +7019,9 @@ 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_utils14.glob)("**", globOptions);
+  const files = await (0, import_build_utils15.glob)("**", globOptions);
   if (djangoStatic?.manifestRelPath) {
-    files[djangoStatic.manifestRelPath] = new import_build_utils14.FileFsRef({
+    files[djangoStatic.manifestRelPath] = new import_build_utils15.FileFsRef({
       fsPath: (0, import_path13.join)(workPath, djangoStatic.manifestRelPath)
     });
   }
@@ -6972,12 +7058,12 @@ from vercel_runtime.vc_init import vc_handler
     }
   });
   const handlerPyFilename = "vc__handler__python";
-  files[`${handlerPyFilename}.py`] = new import_build_utils14.FileBlob({ data: runtimeTrampoline });
+  files[`${handlerPyFilename}.py`] = new import_build_utils15.FileBlob({ data: runtimeTrampoline });
   if (config.framework === "fasthtml") {
     const { SESSKEY = "" } = process.env;
-    files[".sesskey"] = new import_build_utils14.FileBlob({ data: `"${SESSKEY}"` });
+    files[".sesskey"] = new import_build_utils15.FileBlob({ data: `"${SESSKEY}"` });
   }
-  const output = new import_build_utils14.Lambda({
+  const output = new import_build_utils15.Lambda({
     files,
     handler: `${handlerPyFilename}.vc_handler`,
     runtime: pythonVersion.runtime,
@@ -6993,33 +7079,56 @@ from vercel_runtime.vc_init import vc_handler
         uvLockPath
       });
     } catch (err) {
-      (0, import_build_utils14.debug)(
+      (0, import_build_utils15.debug)(
         `Failed to write project manifest: ${err instanceof Error ? err.message : String(err)}`
       );
     }
   }
-  if (djangoStatic?.cdnOutputDir) {
-    const lambdaPath = entrypoint.replace(/\.py$/, "");
-    const staticFiles = await (0, import_build_utils14.glob)("**", { cwd: djangoStatic.cdnOutputDir });
-    return {
-      resultVersion: 2,
-      result: {
-        output: {
-          [lambdaPath]: output,
-          ...staticFiles
-        },
-        routes: [
-          { handle: "filesystem" },
-          { src: "/(.*)", dest: `/${lambdaPath}` }
-        ]
-      }
-    };
+  if (!(0, import_build_utils15.isPythonFramework)(framework)) {
+    return { resultVersion: 3, result: { output } };
+  }
+  const lambdaPath = service?.name ? `_svc/${service.name}/index` : "index";
+  const staticFiles = djangoStatic?.cdnOutputDir ? await (0, import_build_utils15.glob)("**", { cwd: djangoStatic.cdnOutputDir }) : {};
+  return {
+    resultVersion: 2,
+    result: {
+      output: {
+        [lambdaPath]: output,
+        ...staticFiles
+      },
+      routes: [
+        { handle: "filesystem" },
+        { src: "/(.*)", dest: `/${lambdaPath}` }
+      ]
+    }
+  };
+};
+var prepareCache = async ({
+  repoRootPath,
+  workPath
+}) => {
+  if (process.env.VERCEL_PYTHON_PREPARE_CACHE !== "1") {
+    return {};
   }
-  return { resultVersion: 3, result: { output } };
+  const root = repoRootPath || workPath;
+  const ignore = ["**/*.pyc", "**/__pycache__/**"];
+  const uvCacheDir = getUvCacheDir(workPath);
+  try {
+    const uvPath = findUvInPath();
+    if (uvPath) {
+      const uv = new UvRunner(uvPath, uvCacheDir);
+      await uv.cachePrune();
+    }
+  } catch {
+  }
+  return (0, import_build_utils15.glob)("**/.vercel/python/{.venv,services/*/.venv,cache/uv}/**", {
+    cwd: root,
+    ignore
+  });
 };
 var shouldServe = (opts) => {
   const framework = opts.config.framework;
-  if ((0, import_build_utils14.isPythonFramework)(framework)) {
+  if ((0, import_build_utils15.isPythonFramework)(framework)) {
     const requestPath = opts.requestPath.replace(/\/$/, "");
     if (requestPath.startsWith("api") && opts.hasMatched) {
       return false;
@@ -7055,6 +7164,7 @@ function hasProp(obj, key) {
   downloadFilesInWorkPath,
   installRequirement,
   installRequirementsFile,
+  prepareCache,
   runFrameworkHook,
   shouldServe,
   startDevServer,