@vercel/python 6.29.0 → 6.30.1

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,
@@ -3224,19 +3225,19 @@ __export(src_exports, {
 });
 module.exports = __toCommonJS(src_exports);
 var import_child_process3 = require("child_process");
-var import_fs11 = __toESM(require("fs"));
+var import_fs12 = __toESM(require("fs"));
 var import_path13 = require("path");
 
 // src/package-versions.ts
 var VERCEL_RUNTIME_VERSION = "0.12.0";
-var VERCEL_WORKERS_VERSION = "0.0.13";
+var VERCEL_WORKERS_VERSION = "0.0.16";
 
 // src/index.ts
 var import_build_utils15 = require("@vercel/build-utils");
 
 // src/install.ts
 var import_execa3 = __toESM(require_execa());
-var import_fs3 = __toESM(require("fs"));
+var import_fs4 = __toESM(require("fs"));
 var import_path5 = require("path");
 var import_build_utils4 = require("@vercel/build-utils");
 var import_python_analysis2 = require("@vercel/python-analysis");
@@ -3261,14 +3262,25 @@ 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";
+var KNOWN_UV_PATH = "/usr/local/bin/uv";
+function findUvOnBuildImage(knownPath = KNOWN_UV_PATH) {
+  if (!process.env.VERCEL_BUILD_IMAGE)
+    return null;
+  return import_fs.default.existsSync(knownPath) ? knownPath : null;
+}
 function findUvInPath() {
-  return import_which.default.sync("uv", { nothrow: true });
+  return findUvOnBuildImage() ?? 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 +3329,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 +3378,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 +3422,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
     };
@@ -3424,6 +3454,9 @@ async function getUserScriptsDir(pythonPath) {
   }
 }
 async function findUvBinary(pythonPath) {
+  const buildImageUv = findUvOnBuildImage();
+  if (buildImageUv)
+    return buildImageUv;
   const found = import_which.default.sync("uv", { nothrow: true });
   if (found)
     return found;
@@ -3499,11 +3532,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 +3579,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 +3589,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) {
@@ -3667,6 +3738,7 @@ function detectPlatform() {
 
 // src/version.ts
 var import_path4 = require("path");
+var import_fs3 = require("fs");
 var import_build_utils3 = require("@vercel/build-utils");
 var import_python_analysis = require("@vercel/python-analysis");
 function pythonVersionString(pv) {
@@ -3870,10 +3942,24 @@ function isDiscontinued({ discontinueDate }) {
   return discontinueDate !== void 0 && discontinueDate.getTime() <= today;
 }
 var installedPythonsCache = null;
+function getInstalledPythonsFromFilesystem(basePath = UV_PYTHON_PATH_PREFIX) {
+  const result = /* @__PURE__ */ new Set();
+  for (const opt of allOptions) {
+    const binPath = (0, import_path4.join)(basePath, "bin", `python${opt.major}.${opt.minor}`);
+    if ((0, import_fs3.existsSync)(binPath)) {
+      result.add(pythonVersionString(opt));
+    }
+  }
+  return result;
+}
 function getInstalledPythons() {
   if (installedPythonsCache !== null) {
     return installedPythonsCache;
   }
+  if (process.env.VERCEL_BUILD_IMAGE) {
+    installedPythonsCache = getInstalledPythonsFromFilesystem();
+    return installedPythonsCache;
+  }
   const uvPath = findUvInPath();
   if (!uvPath) {
     throw new import_build_utils3.NowBuildError({
@@ -3900,6 +3986,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_fs4.default.existsSync(cachedLockPath) && !import_fs4.default.existsSync(targetLockPath)) {
+    (0, import_build_utils4.debug)("Restoring cached uv.lock");
+    await import_fs4.default.promises.copyFile(cachedLockPath, targetLockPath);
+  }
+}
 var makeDependencyCheckCode = (dependency) => `
 from importlib import util
 dep = '${dependency}'.replace('-', '_')
@@ -4024,8 +4119,8 @@ async function ensureUvProject({
   pythonPackage,
   pythonVersion,
   uv,
-  generateLockFile = false,
-  requireBinaryWheels = false
+  requireBinaryWheels = false,
+  cachedLockPath
 }) {
   const { manifestType } = detectInstallSource(pythonPackage, rootDir);
   const manifest = pythonPackage.manifest;
@@ -4044,7 +4139,7 @@ async function ensureUvProject({
     lockPath = (0, import_path5.join)(rootDir, lockFile.path);
     projectDir = (0, import_path5.dirname)(lockPath);
     pyprojectPath = (0, import_path5.join)(projectDir, "pyproject.toml");
-    if (!import_fs3.default.existsSync(pyprojectPath)) {
+    if (!import_fs4.default.existsSync(pyprojectPath)) {
       throw new Error(
         `Expected "pyproject.toml" next to "${lockFile.kind}" in "${projectDir}"`
       );
@@ -4071,24 +4166,19 @@ async function ensureUvProject({
       }
       const content = (0, import_python_analysis2.stringifyManifest)(manifest.data);
       pyprojectPath = (0, import_path5.join)(projectDir, "pyproject.toml");
-      await import_fs3.default.promises.writeFile(pyprojectPath, content);
+      await import_fs4.default.promises.writeFile(pyprojectPath, content);
     }
     const workspaceLockFile = pythonPackage.workspaceLockFile;
     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;
@@ -4103,14 +4193,15 @@ async function ensureUvProject({
       dependencies: []
     });
     const content = (0, import_python_analysis2.stringifyManifest)(minimalManifest);
-    await import_fs3.default.promises.writeFile(pyprojectPath, content);
+    await import_fs4.default.promises.writeFile(pyprojectPath, content);
+    await restoreCachedLock(cachedLockPath, projectDir);
     await uv.lock({
       projectDir,
       venvPath,
       ...requireBinaryWheels ? { noBuild: true, upgrade: true } : {}
     });
   }
-  const resolvedLockPath = lockPath && import_fs3.default.existsSync(lockPath) ? lockPath : (0, import_path5.join)(projectDir, "uv.lock");
+  const resolvedLockPath = lockPath && import_fs4.default.existsSync(lockPath) ? lockPath : (0, import_path5.join)(projectDir, "uv.lock");
   return {
     projectDir,
     pyprojectPath,
@@ -4136,7 +4227,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) {
@@ -4211,12 +4302,12 @@ async function installRequirementsFile({
 }
 
 // src/dependency-externalizer.ts
-var import_fs4 = __toESM(require("fs"));
+var import_fs5 = __toESM(require("fs"));
 var import_util = require("util");
 var import_path6 = require("path");
 var import_build_utils5 = require("@vercel/build-utils");
 var import_python_analysis3 = require("@vercel/python-analysis");
-var readFile = (0, import_util.promisify)(import_fs4.default.readFile);
+var readFile = (0, import_util.promisify)(import_fs5.default.readFile);
 var LAMBDA_SIZE_THRESHOLD_BYTES = 245 * 1024 * 1024;
 var LAMBDA_EPHEMERAL_STORAGE_BYTES = 500 * 1024 * 1024;
 var PythonDependencyExternalizer = class {
@@ -4419,7 +4510,7 @@ To fix this, either:
     if (process.env.VERCEL_BUILD_IMAGE) {
       try {
         const uvBinaryPath = await getUvBinaryForBundling(this.pythonPath);
-        const uvStats = await import_fs4.default.promises.stat(uvBinaryPath);
+        const uvStats = await import_fs5.default.promises.stat(uvBinaryPath);
         runtimeToolingOverhead = uvStats.size;
       } catch {
         runtimeToolingOverhead = 50 * 1024 * 1024;
@@ -4431,8 +4522,8 @@ To fix this, either:
     const isOutsideWorkPath = projectDirRel.startsWith("..") || uvLockRel.startsWith("..");
     if (isOutsideWorkPath) {
       const pyprojectPath = (0, import_path6.join)(this.uvProjectDir, "pyproject.toml");
-      const pyprojectStats = await import_fs4.default.promises.stat(pyprojectPath).catch(() => null);
-      const uvLockStats = await import_fs4.default.promises.stat(this.uvLockPath).catch(() => null);
+      const pyprojectStats = await import_fs5.default.promises.stat(pyprojectPath).catch(() => null);
+      const uvLockStats = await import_fs5.default.promises.stat(this.uvLockPath).catch(() => null);
       if (pyprojectStats)
         runtimeToolingOverhead += pyprojectStats.size;
       if (uvLockStats)
@@ -4487,9 +4578,9 @@ To fix this, either:
         const uvBinaryPath = await getUvBinaryForBundling(this.pythonPath);
         const uvBundleDir = (0, import_path6.join)(this.workPath, UV_BUNDLE_DIR);
         const uvLocalPath = (0, import_path6.join)(uvBundleDir, "uv");
-        await import_fs4.default.promises.mkdir(uvBundleDir, { recursive: true });
-        await import_fs4.default.promises.copyFile(uvBinaryPath, uvLocalPath);
-        await import_fs4.default.promises.chmod(uvLocalPath, 493);
+        await import_fs5.default.promises.mkdir(uvBundleDir, { recursive: true });
+        await import_fs5.default.promises.copyFile(uvBinaryPath, uvLocalPath);
+        await import_fs5.default.promises.chmod(uvLocalPath, 493);
         const uvBundlePath = `${UV_BUNDLE_DIR}/uv`;
         files[uvBundlePath] = new import_build_utils5.FileFsRef({
           fsPath: uvLocalPath,
@@ -4662,7 +4753,7 @@ async function mirrorPackagesIntoVendor({
   const includeSet = includePackages ? new Set(includePackages.map(import_python_analysis3.normalizePackageName)) : null;
   const sitePackageDirs = await getVenvSitePackagesDirs(venvPath);
   for (const dir of sitePackageDirs) {
-    if (!import_fs4.default.existsSync(dir))
+    if (!import_fs5.default.existsSync(dir))
       continue;
     const resolvedDir = (0, import_path6.resolve)(dir);
     const dirPrefix = resolvedDir + import_path6.sep;
@@ -4679,7 +4770,7 @@ async function mirrorPackagesIntoVendor({
           continue;
         }
         const srcFsPath = (0, import_path6.join)(dir, filePath);
-        if (!import_fs4.default.existsSync(srcFsPath)) {
+        if (!import_fs5.default.existsSync(srcFsPath)) {
           continue;
         }
         const bundlePath = (0, import_path6.join)(vendorDirName, filePath).replace(/\\/g, "/");
@@ -4698,7 +4789,7 @@ async function calculateBundleSize(files) {
     const file = files[filePath];
     if ("fsPath" in file && file.fsPath) {
       try {
-        const stats = await import_fs4.default.promises.stat(file.fsPath);
+        const stats = await import_fs5.default.promises.stat(file.fsPath);
         totalSize += stats.size;
       } catch (err) {
         console.warn(
@@ -4731,7 +4822,7 @@ async function calculatePerPackageSizes(venvPath) {
   const sizes = /* @__PURE__ */ new Map();
   const sitePackageDirs = await getVenvSitePackagesDirs(venvPath);
   for (const dir of sitePackageDirs) {
-    if (!import_fs4.default.existsSync(dir))
+    if (!import_fs5.default.existsSync(dir))
       continue;
     const resolvedDir = (0, import_path6.resolve)(dir);
     const dirPrefix = resolvedDir + import_path6.sep;
@@ -4747,7 +4838,7 @@ async function calculatePerPackageSizes(venvPath) {
           continue;
         }
         try {
-          const stats = await import_fs4.default.promises.stat((0, import_path6.join)(dir, filePath));
+          const stats = await import_fs5.default.promises.stat((0, import_path6.join)(dir, filePath));
           totalSize += stats.size;
         } catch {
         }
@@ -4759,7 +4850,7 @@ async function calculatePerPackageSizes(venvPath) {
 }
 
 // src/diagnostics.ts
-var import_fs5 = __toESM(require("fs"));
+var import_fs6 = __toESM(require("fs"));
 var import_path7 = require("path");
 var import_build_utils6 = require("@vercel/build-utils");
 var import_python_analysis4 = require("@vercel/python-analysis");
@@ -4876,7 +4967,7 @@ async function generateProjectManifest({
   const directEntries = [];
   const transitiveEntries = [];
   {
-    const content = await import_fs5.default.promises.readFile(uvLockPath, "utf-8");
+    const content = await import_fs6.default.promises.readFile(uvLockPath, "utf-8");
     const uvLock = (0, import_python_analysis4.parseUvLock)(content, uvLockPath);
     const projectName = project?.name;
     const excludeSet = new Set(
@@ -4980,15 +5071,15 @@ async function generateProjectManifest({
     ]
   };
   const outPath = (0, import_path7.join)(workPath, DIAGNOSTICS_PATH);
-  await import_fs5.default.promises.mkdir((0, import_path7.dirname)(outPath), { recursive: true });
-  await import_fs5.default.promises.writeFile(outPath, JSON.stringify(manifest, null, 2));
+  await import_fs6.default.promises.mkdir((0, import_path7.dirname)(outPath), { recursive: true });
+  await import_fs6.default.promises.writeFile(outPath, JSON.stringify(manifest, null, 2));
 }
 var diagnostics = async ({
   workPath
 }) => {
   try {
     const manifestPath = (0, import_path7.join)(workPath, DIAGNOSTICS_PATH);
-    const data = await import_fs5.default.promises.readFile(manifestPath, "utf-8");
+    const data = await import_fs6.default.promises.readFile(manifestPath, "utf-8");
     return {
       [MANIFEST_FILENAME]: new import_build_utils6.FileBlob({ data })
     };
@@ -5002,14 +5093,14 @@ var diagnostics = async ({
 
 // src/start-dev-server.ts
 var import_child_process2 = require("child_process");
-var import_fs7 = require("fs");
+var import_fs8 = require("fs");
 var import_path9 = require("path");
 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());
 
 // src/entrypoint.ts
-var import_fs6 = __toESM(require("fs"));
+var import_fs7 = __toESM(require("fs"));
 var import_path8 = require("path");
 var import_build_utils7 = require("@vercel/build-utils");
 var import_build_utils8 = require("@vercel/build-utils");
@@ -5036,7 +5127,7 @@ function getCandidateEntrypointsInDirs(dirs) {
 }
 async function fileExists(filePath) {
   try {
-    const stat = await import_fs6.default.promises.stat(filePath);
+    const stat = await import_fs7.default.promises.stat(filePath);
     return stat.isFile();
   } catch {
     return false;
@@ -5046,7 +5137,7 @@ async function checkEntrypoint(workPath, relPath) {
   const absPath = (0, import_path8.join)(workPath, relPath);
   if (!await fileExists(absPath))
     return null;
-  const content = await import_fs6.default.promises.readFile(absPath, "utf-8");
+  const content = await import_fs7.default.promises.readFile(absPath, "utf-8");
   return (0, import_python_analysis5.findAppOrHandler)(content);
 }
 async function getPyprojectEntrypoint(workPath) {
@@ -5084,7 +5175,7 @@ async function findValidEntrypoint(workPath, candidates) {
 async function checkDjangoManage(workPath) {
   const managePath = (0, import_path8.join)(workPath, "manage.py");
   try {
-    const content = await import_fs6.default.promises.readFile(managePath, "utf-8");
+    const content = await import_fs7.default.promises.readFile(managePath, "utf-8");
     if (!content.includes("DJANGO_SETTINGS_MODULE"))
       return false;
     (0, import_build_utils8.debug)(`Found Django manage.py with DJANGO_SETTINGS_MODULE at ${workPath}`);
@@ -5095,7 +5186,7 @@ async function checkDjangoManage(workPath) {
 }
 async function getSubdirectories(workPath) {
   try {
-    const entries = await import_fs6.default.promises.readdir(workPath, {
+    const entries = await import_fs7.default.promises.readdir(workPath, {
       withFileTypes: true
     });
     return entries.filter((e) => e.isDirectory() && !e.name.startsWith(".")).map((e) => e.name).sort();
@@ -5269,10 +5360,10 @@ async function syncDependencies({
   }
   if (manifest?.origin && manifestType === "pyproject.toml") {
     const syncDir = (0, import_path9.join)(workPath, ".vercel", "python", "sync");
-    (0, import_fs7.mkdirSync)(syncDir, { recursive: true });
+    (0, import_fs8.mkdirSync)(syncDir, { recursive: true });
     const tempPyproject = (0, import_path9.join)(syncDir, "pyproject.toml");
     const content = (0, import_python_analysis6.stringifyManifest)(manifest.data);
-    (0, import_fs7.writeFileSync)(tempPyproject, content, "utf8");
+    (0, import_fs8.writeFileSync)(tempPyproject, content, "utf8");
     manifestPath = tempPyproject;
     (0, import_build_utils10.debug)(
       `Wrote converted ${manifest.origin.kind} manifest to ${tempPyproject}`
@@ -5425,7 +5516,7 @@ async function doInstallVercelRuntime({
   onStdout,
   onStderr
 }) {
-  (0, import_fs7.mkdirSync)(targetDir, { recursive: true });
+  (0, import_fs8.mkdirSync)(targetDir, { recursive: true });
   const localRuntimeDir = (0, import_path9.join)(
     __dirname,
     "..",
@@ -5434,14 +5525,14 @@ async function doInstallVercelRuntime({
     "python",
     "vercel-runtime"
   );
-  const isLocalDev = (0, import_fs7.existsSync)((0, import_path9.join)(localRuntimeDir, "pyproject.toml"));
+  const isLocalDev = (0, import_fs8.existsSync)((0, import_path9.join)(localRuntimeDir, "pyproject.toml"));
   const runtimeDep = env.VERCEL_RUNTIME_PYTHON || (isLocalDev ? localRuntimeDir : `vercel-runtime==${VERCEL_RUNTIME_VERSION}`);
   if (!isLocalDev && !env.VERCEL_RUNTIME_PYTHON) {
     const distInfo = (0, import_path9.join)(
       targetDir,
       `vercel_runtime-${VERCEL_RUNTIME_VERSION}.dist-info`
     );
-    if ((0, import_fs7.existsSync)(distInfo)) {
+    if ((0, import_fs8.existsSync)(distInfo)) {
       (0, import_build_utils10.debug)(
         `vercel-runtime ${VERCEL_RUNTIME_VERSION} already installed, skipping`
       );
@@ -5521,7 +5612,7 @@ async function doInstallVercelWorkers({
   onStdout,
   onStderr
 }) {
-  (0, import_fs7.mkdirSync)(targetDir, { recursive: true });
+  (0, import_fs8.mkdirSync)(targetDir, { recursive: true });
   const localWorkersDir = (0, import_path9.join)(
     __dirname,
     "..",
@@ -5530,14 +5621,14 @@ async function doInstallVercelWorkers({
     "python",
     "vercel-workers"
   );
-  const isLocalDev = (0, import_fs7.existsSync)((0, import_path9.join)(localWorkersDir, "pyproject.toml"));
+  const isLocalDev = (0, import_fs8.existsSync)((0, import_path9.join)(localWorkersDir, "pyproject.toml"));
   const workersDep = env.VERCEL_WORKERS_PYTHON || (isLocalDev ? localWorkersDir : `vercel-workers==${VERCEL_WORKERS_VERSION}`);
   if (!isLocalDev && !env.VERCEL_WORKERS_PYTHON) {
     const distInfo = (0, import_path9.join)(
       targetDir,
       `vercel_workers-${VERCEL_WORKERS_VERSION}.dist-info`
     );
-    if ((0, import_fs7.existsSync)(distInfo)) {
+    if ((0, import_fs8.existsSync)(distInfo)) {
       (0, import_build_utils10.debug)(
         `vercel-workers ${VERCEL_WORKERS_VERSION} already installed, skipping`
       );
@@ -5627,10 +5718,10 @@ function installGlobalCleanupHandlers() {
 function createDevShim(workPath, entry, modulePath, serviceName, framework, variableName) {
   try {
     const vercelPythonDir = serviceName ? (0, import_path9.join)(workPath, ".vercel", "python", "services", serviceName) : (0, import_path9.join)(workPath, ".vercel", "python");
-    (0, import_fs7.mkdirSync)(vercelPythonDir, { recursive: true });
+    (0, import_fs8.mkdirSync)(vercelPythonDir, { recursive: true });
     let qualifiedModule = modulePath;
     let extraPythonPath;
-    if ((0, import_fs7.existsSync)((0, import_path9.join)(workPath, "__init__.py"))) {
+    if ((0, import_fs8.existsSync)((0, import_path9.join)(workPath, "__init__.py"))) {
       const pkgName = (0, import_path9.basename)(workPath);
       qualifiedModule = `${pkgName}.${modulePath}`;
       extraPythonPath = (0, import_path9.dirname)(workPath);
@@ -5643,9 +5734,9 @@ function createDevShim(workPath, entry, modulePath, serviceName, framework, vari
       "templates",
       `${DEV_SHIM_MODULE}.py`
     );
-    const template = (0, import_fs7.readFileSync)(templatePath, "utf8");
+    const template = (0, import_fs8.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_fs8.writeFileSync)(shimPath, shimSource, "utf8");
     (0, import_build_utils10.debug)(`Prepared Python dev shim at ${shimPath}`);
     return {
       module: DEV_SHIM_MODULE,
@@ -5664,7 +5755,12 @@ async function getMultiServicePythonRunner(workPath, env, systemPython, uvPath)
     return { command: pythonCmd, args: [] };
   }
   const venvPath = (0, import_path9.join)(workPath, ".venv");
-  await ensureVenv({ pythonPath: systemPython, venvPath, uvPath, quiet: true });
+  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);
@@ -5947,7 +6043,7 @@ var matplotlibQuirk = {
 };
 
 // src/quirks/litellm.ts
-var import_fs8 = __toESM(require("fs"));
+var import_fs9 = __toESM(require("fs"));
 var import_path10 = require("path");
 var import_build_utils11 = require("@vercel/build-utils");
 var LAMBDA_ROOT = "/var/task";
@@ -5961,7 +6057,7 @@ async function findConfigFile(workPath) {
   for (const name of CONFIG_CANDIDATES) {
     const candidate = (0, import_path10.join)(workPath, name);
     try {
-      await import_fs8.default.promises.access(candidate);
+      await import_fs9.default.promises.access(candidate);
       return name;
     } catch {
     }
@@ -5983,7 +6079,7 @@ var litellmQuirk = {
         "schema.prisma"
       );
       try {
-        await import_fs8.default.promises.access(schemaPath);
+        await import_fs9.default.promises.access(schemaPath);
         (0, import_build_utils11.debug)(`LiteLLM quirk: found schema at ${schemaPath}`);
         buildEnv.PRISMA_SCHEMA_PATH = schemaPath;
         break;
@@ -6010,7 +6106,7 @@ var litellmQuirk = {
 };
 
 // src/quirks/prisma.ts
-var import_fs9 = __toESM(require("fs"));
+var import_fs10 = __toESM(require("fs"));
 var import_path11 = require("path");
 var import_execa4 = __toESM(require_execa());
 var import_build_utils12 = require("@vercel/build-utils");
@@ -6053,7 +6149,7 @@ async function findUserSchema(workPath) {
   if (envPath) {
     const resolved = (0, import_path11.isAbsolute)(envPath) ? envPath : (0, import_path11.join)(workPath, envPath);
     try {
-      await import_fs9.default.promises.access(resolved);
+      await import_fs10.default.promises.access(resolved);
       return resolved;
     } catch {
       (0, import_build_utils12.debug)(`PRISMA_SCHEMA_PATH=${envPath} not found at ${resolved}`);
@@ -6066,7 +6162,7 @@ async function findUserSchema(workPath) {
   ];
   for (const candidate of candidates) {
     try {
-      await import_fs9.default.promises.access(candidate);
+      await import_fs10.default.promises.access(candidate);
       return candidate;
     } catch {
     }
@@ -6077,7 +6173,7 @@ async function collectFiles(dir, base) {
   const result = [];
   let entries;
   try {
-    entries = await import_fs9.default.promises.readdir(dir, { withFileTypes: true });
+    entries = await import_fs10.default.promises.readdir(dir, { withFileTypes: true });
   } catch {
     return result;
   }
@@ -6102,7 +6198,7 @@ async function cleanCacheArtifacts(cacheDir, extras = []) {
   ];
   for (const p of paths) {
     try {
-      await import_fs9.default.promises.rm(p, { recursive: true, force: true });
+      await import_fs10.default.promises.rm(p, { recursive: true, force: true });
     } catch (err) {
       console.warn(
         `could not clean up ${p}: ${err instanceof Error ? err.message : String(err)}`
@@ -6136,7 +6232,7 @@ var prismaQuirk = {
     let sitePackages;
     for (const dir of sitePackagesDirs) {
       try {
-        await import_fs9.default.promises.access((0, import_path11.join)(dir, "prisma"));
+        await import_fs10.default.promises.access((0, import_path11.join)(dir, "prisma"));
         sitePackages = dir;
         break;
       } catch {
@@ -6149,14 +6245,14 @@ var prismaQuirk = {
       return {};
     }
     const cacheDir = (0, import_path11.join)(sitePackages, "prisma", "__bincache__");
-    await import_fs9.default.promises.mkdir(cacheDir, { recursive: true });
+    await import_fs10.default.promises.mkdir(cacheDir, { recursive: true });
     const generateEnv = {
       ...pythonEnv,
       PRISMA_BINARY_CACHE_DIR: cacheDir
     };
     const generatedDir = (0, import_path11.join)(workPath, "_prisma_generated");
     const dummySchemaPath = (0, import_path11.join)(workPath, DUMMY_SCHEMA_NAME);
-    await import_fs9.default.promises.writeFile(
+    await import_fs10.default.promises.writeFile(
       dummySchemaPath,
       buildDummySchema(generatedDir)
     );
@@ -6187,18 +6283,18 @@ var prismaQuirk = {
     const nodeModulesDir = (0, import_path11.join)(cacheDir, "node_modules", "prisma");
     let engineCopied = false;
     try {
-      const entries = await import_fs9.default.promises.readdir(nodeModulesDir);
+      const entries = await import_fs10.default.promises.readdir(nodeModulesDir);
       for (const entry of entries) {
         if (!entry.startsWith(srcBinaryPrefix))
           continue;
         const srcPath = (0, import_path11.join)(nodeModulesDir, entry);
         const destPath = (0, import_path11.join)(cacheDir, runtimeName);
         try {
-          await import_fs9.default.promises.access(destPath);
+          await import_fs10.default.promises.access(destPath);
           (0, import_build_utils12.debug)(`Engine binary: ${runtimeName} already exists, skipping`);
         } catch {
           (0, import_build_utils12.debug)(`Engine binary: copying ${entry} -> ${runtimeName}`);
-          await import_fs9.default.promises.copyFile(srcPath, destPath);
+          await import_fs10.default.promises.copyFile(srcPath, destPath);
         }
         engineCopied = true;
       }
@@ -6216,15 +6312,15 @@ var prismaQuirk = {
       });
     }
     const shimPath = (0, import_path11.join)(cacheDir, "openssl");
-    await import_fs9.default.promises.writeFile(
+    await import_fs10.default.promises.writeFile(
       shimPath,
       `#!/bin/sh
 echo "OpenSSL ${RUNTIME_OPENSSL_VERSION}.0 1 Jan 2024 (Library: OpenSSL ${RUNTIME_OPENSSL_VERSION}.0)"
 `
     );
-    await import_fs9.default.promises.chmod(shimPath, 493);
+    await import_fs10.default.promises.chmod(shimPath, 493);
     for (const p of [generatedDir, dummySchemaPath]) {
-      await import_fs9.default.promises.rm(p, { recursive: true, force: true });
+      await import_fs10.default.promises.rm(p, { recursive: true, force: true });
     }
     await cleanCacheArtifacts(cacheDir);
     const generateMode = (process.env.VERCEL_PRISMA_GENERATE_CLIENT ?? "auto").toLowerCase();
@@ -6397,12 +6493,12 @@ async function runQuirks(ctx) {
 }
 
 // src/django.ts
-var import_fs10 = __toESM(require("fs"));
+var import_fs11 = __toESM(require("fs"));
 var import_path12 = require("path");
 var import_execa5 = __toESM(require_execa());
 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");
+var script = import_fs11.default.readFileSync(scriptPath, "utf-8");
 async function getDjangoSettings(projectDir, env) {
   const { stdout } = await (0, import_execa5.default)("python", ["-c", script], {
     env,
@@ -6433,7 +6529,7 @@ async function runDjangoCollectStatic(venvPath, workPath, env, outputStaticDir,
     ...installedApps.map((app) => (0, import_path12.join)(workPath, ...app.split("."), "static")),
     // TODO: Deal with optional prefixes in STATICFILES_DIRS.
     ...staticfilesDirs.map((d) => Array.isArray(d) ? d[1] : d)
-  ].filter((d) => import_fs10.default.existsSync(d));
+  ].filter((d) => import_fs11.default.existsSync(d));
   if (storageBackend.startsWith("storages.backends.")) {
     console.log(
       "django-storages detected \u2014 running collectstatic with original settings"
@@ -6457,7 +6553,7 @@ async function runDjangoCollectStatic(venvPath, workPath, env, outputStaticDir,
   }
   const staticUrlPath = staticUrl.replace(/^\/|\/$/g, "") || "static";
   const staticOutputDir = (0, import_path12.join)(outputStaticDir, staticUrlPath);
-  await import_fs10.default.promises.mkdir(staticOutputDir, { recursive: true });
+  await import_fs11.default.promises.mkdir(staticOutputDir, { recursive: true });
   const shimPath = (0, import_path12.join)(workPath, "_vercel_collectstatic_settings.py");
   const shimLines = [
     `from ${settingsModule} import *`,
@@ -6466,7 +6562,7 @@ async function runDjangoCollectStatic(venvPath, workPath, env, outputStaticDir,
   if (whitenoiseUseFinders) {
     shimLines.push(`WHITENOISE_USE_FINDERS = False`);
   }
-  await import_fs10.default.promises.writeFile(shimPath, shimLines.join("\n") + "\n");
+  await import_fs11.default.promises.writeFile(shimPath, shimLines.join("\n") + "\n");
   try {
     console.log("Running collectstatic...");
     await (0, import_execa5.default)(pythonPath, ["manage.py", "collectstatic", "--noinput"], {
@@ -6477,7 +6573,7 @@ async function runDjangoCollectStatic(venvPath, workPath, env, outputStaticDir,
       cwd: workPath
     });
   } finally {
-    await import_fs10.default.promises.unlink(shimPath).catch(() => {
+    await import_fs11.default.promises.unlink(shimPath).catch(() => {
     });
   }
   const MANIFEST_STORAGE_BACKENDS = [
@@ -6489,8 +6585,8 @@ async function runDjangoCollectStatic(venvPath, workPath, env, outputStaticDir,
     const manifestSrc = (0, import_path12.join)(staticOutputDir, "staticfiles.json");
     const resolvedStaticRoot = (0, import_path12.resolve)(workPath, staticRoot);
     const manifestDest = (0, import_path12.join)(resolvedStaticRoot, "staticfiles.json");
-    await import_fs10.default.promises.mkdir(resolvedStaticRoot, { recursive: true });
-    await import_fs10.default.promises.copyFile(manifestSrc, manifestDest);
+    await import_fs11.default.promises.mkdir(resolvedStaticRoot, { recursive: true });
+    await import_fs11.default.promises.copyFile(manifestSrc, manifestDest);
     manifestRelPath = (0, import_path12.relative)(workPath, manifestDest);
     (0, import_build_utils14.debug)(`Copied staticfiles.json to ${manifestDest} for Lambda bundle`);
   }
@@ -6504,7 +6600,7 @@ async function runDjangoCollectStatic(venvPath, workPath, env, outputStaticDir,
 
 // src/index.ts
 var import_python_analysis9 = require("@vercel/python-analysis");
-var writeFile = import_fs11.default.promises.writeFile;
+var writeFile = import_fs12.default.promises.writeFile;
 var version = -1;
 async function runFrameworkHook(framework, ctx) {
   const hook = framework ? frameworkHooks[framework] : void 0;
@@ -6676,10 +6772,19 @@ var build = async ({
     );
   }
   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_fs12.default.existsSync((0, import_path13.join)(venvPath, "pyvenv.cfg"));
+  const hasCachedUv = import_fs12.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_utils15.isPythonFramework)(framework)) {
@@ -6708,13 +6813,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();
@@ -6732,6 +6837,13 @@ var build = async ({
     installCommand: projectInstallCommand || void 0
   }).trace(async () => {
     if (projectInstallCommand) {
+      await import_fs12.default.promises.rm(venvPath, { recursive: true, force: true });
+      await ensureVenv({
+        pythonVersion,
+        venvPath,
+        uvCacheDir,
+        quiet: true
+      });
       console.log(
         `Running "install" command: \`${projectInstallCommand}\`...`
       );
@@ -6742,18 +6854,21 @@ var build = async ({
       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 +6876,8 @@ var build = async ({
         pythonPackage,
         pythonVersion: pythonVersionString(pythonVersion),
         uv,
-        generateLockFile: true,
-        requireBinaryWheels: false
+        requireBinaryWheels: false,
+        cachedLockPath
       });
       uvLockPath = lockPath;
       uvProjectDir = projectDir;
@@ -6773,6 +6888,10 @@ var build = async ({
         frozen: lockFileProvidedByUser,
         locked: !lockFileProvidedByUser
       });
+      if (lockPath && import_fs12.default.existsSync(lockPath)) {
+        await import_fs12.default.promises.mkdir(uvCacheDir, { recursive: true });
+        await import_fs12.default.promises.copyFile(lockPath, cachedLockPath);
+      }
     }
   });
   if ((0, import_build_utils15.isPythonFramework)(framework)) {
@@ -6841,7 +6960,7 @@ var build = async ({
   const handlerFunction = typeof config?.handlerFunction === "string" ? config.handlerFunction : void 0;
   if (handlerFunction) {
     const entrypointPath = (0, import_path13.join)(workPath, entrypoint);
-    const source = await import_fs11.default.promises.readFile(entrypointPath, "utf-8");
+    const source = await import_fs12.default.promises.readFile(entrypointPath, "utf-8");
     const found = await (0, import_python_analysis9.containsTopLevelCallable)(source, handlerFunction);
     if (!found) {
       throw new import_build_utils15.NowBuildError({
@@ -7008,6 +7127,29 @@ from vercel_runtime.vc_init import vc_handler
     }
   };
 };
+var prepareCache = async ({
+  repoRootPath,
+  workPath
+}) => {
+  if (process.env.VERCEL_PYTHON_PREPARE_CACHE !== "1") {
+    return {};
+  }
+  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_utils15.isPythonFramework)(framework)) {
@@ -7046,6 +7188,7 @@ function hasProp(obj, key) {
   downloadFilesInWorkPath,
   installRequirement,
   installRequirementsFile,
+  prepareCache,
   runFrameworkHook,
   shouldServe,
   startDevServer,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/python",
-  "version": "6.29.0",
+  "version": "6.30.1",
   "main": "./dist/index.js",
   "license": "Apache-2.0",
   "homepage": "https://vercel.com/docs/runtimes#official-runtimes/python",
@@ -36,7 +36,7 @@
     "smol-toml": "1.5.2",
     "vitest": "2.1.4",
     "which": "3.0.0",
-    "@vercel/build-utils": "13.12.1",
+    "@vercel/build-utils": "13.14.2",
     "@vercel/error-utils": "2.0.3",
     "@vercel/python-runtime": "0.12.0"
   },