vercel-cli 48.6.6__py3-none-any.whl → 50.4.6__py3-none-any.whl

vercel_cli/vendor/node_modules/@vercel/python/dist/index.js

@@ -137,12 +137,12 @@ var require_isexe = __commonJS({
         if (typeof Promise !== "function") {
           throw new TypeError("callback not provided");
         }
-        return new Promise(function(resolve, reject) {
+        return new Promise(function(resolve2, reject) {
           isexe(path, options || {}, function(er, is) {
             if (er) {
               reject(er);
             } else {
-              resolve(is);
+              resolve2(is);
             }
           });
         });
@@ -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 debug5;
+    var debug6;
     if (typeof process === "object" && process.env && process.env.NODE_DEBUG && /\bsemver\b/i.test(process.env.NODE_DEBUG)) {
-      debug5 = function() {
+      debug6 = function() {
         var args = Array.prototype.slice.call(arguments, 0);
         args.unshift("SEMVER");
         console.log.apply(console, args);
       };
     } else {
-      debug5 = function() {
+      debug6 = 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++) {
-      debug5(i, src[i]);
+      debug6(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);
       }
-      debug5("SemVer", version2, options);
+      debug6("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) {
-      debug5("SemVer.compare", this.version, this.options, other);
+      debug6("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];
-        debug5("prerelease compare", i2, a, b);
+        debug6("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(" ");
-      debug5("comparator", comp, options);
+      debug6("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;
       }
-      debug5("comp", this);
+      debug6("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) {
-      debug5("Comparator.test", version2, this.options.loose);
+      debug6("Comparator.test", version2, this.options.loose);
       if (this.semver === ANY) {
         return true;
       }
@@ -989,10 +989,10 @@ var require_semver = __commonJS({
       var rangeTmp;
       if (this.operator === "") {
         rangeTmp = new Range(comp.value, options);
-        return satisfies(this.value, rangeTmp, options);
+        return satisfies2(this.value, rangeTmp, options);
       } else if (comp.operator === "") {
         rangeTmp = new Range(this.value, options);
-        return satisfies(comp.semver, rangeTmp, options);
+        return satisfies2(comp.semver, rangeTmp, options);
       }
       var sameDirectionIncreasing = (this.operator === ">=" || this.operator === ">") && (comp.operator === ">=" || comp.operator === ">");
       var sameDirectionDecreasing = (this.operator === "<=" || this.operator === "<") && (comp.operator === "<=" || comp.operator === "<");
@@ -1050,9 +1050,9 @@ var require_semver = __commonJS({
       var loose = this.options.loose;
       var hr = loose ? safeRe[HYPHENRANGELOOSE] : safeRe[HYPHENRANGE];
       range = range.replace(hr, hyphenReplace);
-      debug5("hyphen replace", range);
+      debug6("hyphen replace", range);
       range = range.replace(safeRe[COMPARATORTRIM], comparatorTrimReplace);
-      debug5("comparator trim", range, safeRe[COMPARATORTRIM]);
+      debug6("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) {
-      debug5("comp", comp, options);
+      debug6("comp", comp, options);
       comp = replaceCarets(comp, options);
-      debug5("caret", comp);
+      debug6("caret", comp);
       comp = replaceTildes(comp, options);
-      debug5("tildes", comp);
+      debug6("tildes", comp);
       comp = replaceXRanges(comp, options);
-      debug5("xrange", comp);
+      debug6("xrange", comp);
       comp = replaceStars(comp, options);
-      debug5("stars", comp);
+      debug6("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) {
-        debug5("tilde", comp, _, M, m, p, pr);
+        debug6("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) {
-          debug5("replaceTilde pr", pr);
+          debug6("replaceTilde pr", pr);
           ret = ">=" + M + "." + m + "." + p + "-" + pr + " <" + M + "." + (+m + 1) + ".0";
         } else {
           ret = ">=" + M + "." + m + "." + p + " <" + M + "." + (+m + 1) + ".0";
         }
-        debug5("tilde return", ret);
+        debug6("tilde return", ret);
         return ret;
       });
     }
@@ -1138,10 +1138,10 @@ var require_semver = __commonJS({
       }).join(" ");
     }
     function replaceCaret(comp, options) {
-      debug5("caret", comp, options);
+      debug6("caret", comp, options);
       var r = options.loose ? safeRe[CARETLOOSE] : safeRe[CARET];
       return comp.replace(r, function(_, M, m, p, pr) {
-        debug5("caret", comp, _, M, m, p, pr);
+        debug6("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) {
-          debug5("replaceCaret pr", pr);
+          debug6("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 {
-          debug5("no pr");
+          debug6("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";
           }
         }
-        debug5("caret return", ret);
+        debug6("caret return", ret);
         return ret;
       });
     }
     function replaceXRanges(comp, options) {
-      debug5("replaceXRanges", comp, options);
+      debug6("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) {
-        debug5("xRange", comp, ret, gtlt, M, m, p, pr);
+        debug6("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";
         }
-        debug5("xRange return", ret);
+        debug6("xRange return", ret);
         return ret;
       });
     }
     function replaceStars(comp, options) {
-      debug5("replaceStars", comp, options);
+      debug6("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++) {
-          debug5(set[i2].semver);
+          debug6(set[i2].semver);
           if (set[i2].semver === ANY) {
             continue;
           }
@@ -1301,8 +1301,8 @@ var require_semver = __commonJS({
       }
       return true;
     }
-    exports.satisfies = satisfies;
-    function satisfies(version2, range, options) {
+    exports.satisfies = satisfies2;
+    function satisfies2(version2, range, options) {
       try {
         range = new Range(range, options);
       } catch (er) {
@@ -1430,7 +1430,7 @@ var require_semver = __commonJS({
         default:
           throw new TypeError('Must provide a hilo val of "<" or ">"');
       }
-      if (satisfies(version2, range, options)) {
+      if (satisfies2(version2, range, options)) {
         return false;
       }
       for (var i2 = 0; i2 < range.set.length; ++i2) {
@@ -1498,7 +1498,7 @@ var require_parse = __commonJS({
     var escape = require_escape();
     var readShebang = require_readShebang();
     var semver = require_semver();
-    var isWin2 = process.platform === "win32";
+    var isWin3 = process.platform === "win32";
     var isExecutableRegExp = /\.(?:com|exe)$/i;
     var isCmdShimRegExp = /node_modules[\\/].bin[\\/][^\\/]+\.cmd$/i;
     var supportsShellOption = niceTry(() => semver.satisfies(process.version, "^4.8.0 || ^5.7.0 || >= 6.0.0", true)) || false;
@@ -1513,7 +1513,7 @@ var require_parse = __commonJS({
       return parsed.file;
     }
     function parseNonShell(parsed) {
-      if (!isWin2) {
+      if (!isWin3) {
         return parsed;
       }
       const commandFile = detectShebang(parsed);
@@ -1535,7 +1535,7 @@ var require_parse = __commonJS({
         return parsed;
       }
       const shellCommand = [parsed.command].concat(parsed.args).join(" ");
-      if (isWin2) {
+      if (isWin3) {
         parsed.command = typeof parsed.options.shell === "string" ? parsed.options.shell : process.env.comspec || "cmd.exe";
         parsed.args = ["/d", "/s", "/c", `"${shellCommand}"`];
         parsed.options.windowsVerbatimArguments = true;
@@ -1578,7 +1578,7 @@ var require_parse = __commonJS({
 var require_enoent = __commonJS({
   "../../node_modules/.pnpm/cross-spawn@6.0.5/node_modules/cross-spawn/lib/enoent.js"(exports, module2) {
     "use strict";
-    var isWin2 = process.platform === "win32";
+    var isWin3 = process.platform === "win32";
     function notFoundError(original, syscall) {
       return Object.assign(new Error(`${syscall} ${original.command} ENOENT`), {
         code: "ENOENT",
@@ -1589,7 +1589,7 @@ var require_enoent = __commonJS({
       });
     }
     function hookChildProcess(cp, parsed) {
-      if (!isWin2) {
+      if (!isWin3) {
         return;
       }
       const originalEmit = cp.emit;
@@ -1604,13 +1604,13 @@ var require_enoent = __commonJS({
       };
     }
     function verifyENOENT(status, parsed) {
-      if (isWin2 && status === 1 && !parsed.file) {
+      if (isWin3 && status === 1 && !parsed.file) {
         return notFoundError(parsed.original, "spawn");
       }
       return null;
     }
     function verifyENOENTSync(status, parsed) {
-      if (isWin2 && status === 1 && !parsed.file) {
+      if (isWin3 && status === 1 && !parsed.file) {
         return notFoundError(parsed.original, "spawnSync");
       }
       return null;
@@ -2042,7 +2042,7 @@ var require_get_stream = __commonJS({
       options = Object.assign({ maxBuffer: Infinity }, options);
       const { maxBuffer } = options;
       let stream;
-      return new Promise((resolve, reject) => {
+      return new Promise((resolve2, reject) => {
         const rejectPromise = (error) => {
           if (error) {
             error.bufferedData = stream.getBufferedValue();
@@ -2054,7 +2054,7 @@ var require_get_stream = __commonJS({
             rejectPromise(error);
             return;
           }
-          resolve();
+          resolve2();
         });
         stream.on("data", () => {
           if (stream.getBufferedLength() > maxBuffer) {
@@ -2078,11 +2078,11 @@ var require_p_finally = __commonJS({
       onFinally = onFinally || (() => {
       });
       return promise.then(
-        (val) => new Promise((resolve) => {
-          resolve(onFinally());
+        (val) => new Promise((resolve2) => {
+          resolve2(onFinally());
         }).then(() => val),
-        (err) => new Promise((resolve) => {
-          resolve(onFinally());
+        (err) => new Promise((resolve2) => {
+          resolve2(onFinally());
         }).then(() => {
           throw err;
         })
@@ -2143,7 +2143,7 @@ var require_signal_exit = __commonJS({
     } else {
       assert = require("assert");
       signals = require_signals();
-      isWin2 = /^win/i.test(process2.platform);
+      isWin3 = /^win/i.test(process2.platform);
       EE = require("events");
       if (typeof EE !== "function") {
         EE = EE.EventEmitter;
@@ -2215,7 +2215,7 @@ var require_signal_exit = __commonJS({
             unload();
             emit("exit", null, sig);
             emit("afterexit", null, sig);
-            if (isWin2 && sig === "SIGHUP") {
+            if (isWin3 && sig === "SIGHUP") {
               sig = "SIGINT";
             }
             process2.kill(process2.pid, sig);
@@ -2272,7 +2272,7 @@ var require_signal_exit = __commonJS({
     }
     var assert;
     var signals;
-    var isWin2;
+    var isWin3;
     var EE;
     var emitter;
     var unload;
@@ -2461,8 +2461,8 @@ var require_execa = __commonJS({
       }
       let ret;
       if (!buffer) {
-        ret = new Promise((resolve, reject) => {
-          process2[stream].once("end", resolve).once("error", reject);
+        ret = new Promise((resolve2, reject) => {
+          process2[stream].once("end", resolve2).once("error", reject);
         });
       } else if (encoding) {
         ret = _getStream(process2[stream], {
@@ -2551,19 +2551,19 @@ ${stderr}${stdout}`;
           spawned.kill(parsed.opts.killSignal);
         }, parsed.opts.timeout);
       }
-      const processDone = new Promise((resolve) => {
+      const processDone = new Promise((resolve2) => {
         spawned.on("exit", (code, signal) => {
           cleanup();
-          resolve({ code, signal });
+          resolve2({ code, signal });
         });
         spawned.on("error", (err) => {
           cleanup();
-          resolve({ error: err });
+          resolve2({ error: err });
         });
         if (spawned.stdin) {
           spawned.stdin.on("error", (err) => {
             cleanup();
-            resolve({ error: err });
+            resolve2({ error: err });
           });
         }
       });
@@ -2651,7 +2651,7 @@ ${stderr}${stdout}`;
 var require_lib = __commonJS({
   "../../node_modules/.pnpm/which@3.0.0/node_modules/which/lib/index.js"(exports, module2) {
     var isexe = require_isexe();
-    var { join: join5, delimiter, sep, posix } = require("path");
+    var { join: join6, delimiter, sep, posix } = require("path");
     var isWindows = process.platform === "win32";
     var rSlash = new RegExp(`[${posix.sep}${sep === posix.sep ? "" : sep}]`.replace(/(\\)/g, "\\$1"));
     var rRel = new RegExp(`^\\.${rSlash.source}`);
@@ -2680,7 +2680,7 @@ var require_lib = __commonJS({
     var getPathPart = (raw, cmd) => {
       const pathPart = /^".*"$/.test(raw) ? raw.slice(1, -1) : raw;
       const prefix = !pathPart && rRel.test(cmd) ? cmd.slice(0, 2) : "";
-      return prefix + join5(pathPart, cmd);
+      return prefix + join6(pathPart, cmd);
     };
     var which3 = async (cmd, opt = {}) => {
       const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
@@ -2751,17 +2751,146 @@ module.exports = __toCommonJS(src_exports);
 var import_fs5 = __toESM(require("fs"));
 var import_util = require("util");
 var import_path5 = require("path");
-var import_build_utils5 = require("@vercel/build-utils");
+var import_build_utils7 = require("@vercel/build-utils");
 
 // src/install.ts
-var import_execa = __toESM(require_execa());
-var import_fs = __toESM(require("fs"));
+var import_execa2 = __toESM(require_execa());
+var import_fs2 = __toESM(require("fs"));
 var import_os = __toESM(require("os"));
-var import_path = require("path");
+var import_path2 = require("path");
 var import_which = __toESM(require_lib());
+var import_build_utils2 = require("@vercel/build-utils");
+
+// src/utils.ts
+var import_fs = __toESM(require("fs"));
+var import_path = require("path");
 var import_build_utils = require("@vercel/build-utils");
+var import_execa = __toESM(require_execa());
 var isWin = process.platform === "win32";
-var uvExec = isWin ? "uv.exe" : "uv";
+var isInVirtualEnv = () => {
+  return process.env.VIRTUAL_ENV;
+};
+function getVenvBinDir(venvPath) {
+  return (0, import_path.join)(venvPath, isWin ? "Scripts" : "bin");
+}
+function useVirtualEnv(workPath, env, systemPython) {
+  const venvDirs = [".venv", "venv"];
+  let pythonCmd = systemPython;
+  for (const venv of venvDirs) {
+    const venvRoot = (0, import_path.join)(workPath, venv);
+    const binDir = process.platform === "win32" ? (0, import_path.join)(venvRoot, "Scripts") : (0, import_path.join)(venvRoot, "bin");
+    const candidates = process.platform === "win32" ? [(0, import_path.join)(binDir, "python.exe"), (0, import_path.join)(binDir, "python")] : [(0, import_path.join)(binDir, "python3"), (0, import_path.join)(binDir, "python")];
+    const found = candidates.find((p) => import_fs.default.existsSync(p));
+    if (found) {
+      pythonCmd = found;
+      env.VIRTUAL_ENV = venvRoot;
+      env.PATH = `${binDir}${import_path.delimiter}${env.PATH || ""}`;
+      return { pythonCmd, venvRoot };
+    }
+  }
+  return { pythonCmd };
+}
+function createVenvEnv(venvPath, baseEnv = process.env) {
+  const env = { ...baseEnv, VIRTUAL_ENV: venvPath };
+  const binDir = getVenvBinDir(venvPath);
+  const existingPath = env.PATH || process.env.PATH || "";
+  env.PATH = existingPath ? `${binDir}${import_path.delimiter}${existingPath}` : binDir;
+  return env;
+}
+async function ensureVenv({
+  pythonPath,
+  venvPath
+}) {
+  const marker = (0, import_path.join)(venvPath, "pyvenv.cfg");
+  try {
+    await import_fs.default.promises.access(marker);
+    return;
+  } catch {
+  }
+  await import_fs.default.promises.mkdir(venvPath, { recursive: true });
+  console.log(`Creating virtual environment at "${venvPath}"...`);
+  await (0, import_execa.default)(pythonPath, ["-m", "venv", venvPath]);
+}
+function getVenvPythonBin(venvPath) {
+  return (0, import_path.join)(getVenvBinDir(venvPath), isWin ? "python.exe" : "python");
+}
+async function runPyprojectScript(workPath, scriptNames, env, useUserVirtualEnv = true) {
+  const pyprojectPath = (0, import_path.join)(workPath, "pyproject.toml");
+  if (!import_fs.default.existsSync(pyprojectPath))
+    return false;
+  let pyproject = null;
+  try {
+    pyproject = await (0, import_build_utils.readConfigFile)(pyprojectPath);
+  } catch {
+    console.error("Failed to parse pyproject.toml");
+    return false;
+  }
+  const scripts = pyproject?.tool?.vercel?.scripts || {};
+  const candidates = typeof scriptNames === "string" ? [scriptNames] : Array.from(scriptNames);
+  const scriptToRun = candidates.find((name) => Boolean(scripts[name]));
+  if (!scriptToRun)
+    return false;
+  const systemPython = process.platform === "win32" ? "python" : "python3";
+  const finalEnv = { ...process.env, ...env };
+  if (useUserVirtualEnv) {
+    useVirtualEnv(workPath, finalEnv, systemPython);
+  }
+  const scriptCommand = scripts[scriptToRun];
+  if (typeof scriptCommand === "string" && scriptCommand.trim()) {
+    console.log(`Executing: ${scriptCommand}`);
+    await (0, import_build_utils.execCommand)(scriptCommand, {
+      cwd: workPath,
+      env: finalEnv
+    });
+    return true;
+  }
+  return false;
+}
+async function runUvCommand(options) {
+  const { uvPath, args, cwd, venvPath } = options;
+  const pretty = `uv ${args.join(" ")}`;
+  (0, import_build_utils.debug)(`Running "${pretty}"...`);
+  if (!uvPath) {
+    throw new Error(`uv is required to run "${pretty}" but is not available`);
+  }
+  try {
+    await (0, import_execa.default)(uvPath, args, {
+      cwd,
+      env: createVenvEnv(venvPath)
+    });
+    return true;
+  } catch (err) {
+    const error = new Error(
+      `Failed to run "${pretty}": ${err instanceof Error ? err.message : String(err)}`
+    );
+    if (err && typeof err === "object") {
+      if ("code" in err) {
+        error.code = err.code;
+      } else if ("signal" in err) {
+        error.code = err.signal;
+      }
+    }
+    throw error;
+  }
+}
+function findDir({
+  file,
+  entryDirectory,
+  workPath,
+  fsFiles
+}) {
+  if (fsFiles[(0, import_path.join)(entryDirectory, file)]) {
+    return (0, import_path.join)(workPath, entryDirectory);
+  }
+  if (fsFiles[file]) {
+    return workPath;
+  }
+  return null;
+}
+
+// src/install.ts
+var isWin2 = process.platform === "win32";
+var uvExec = isWin2 ? "uv.exe" : "uv";
 var makeDependencyCheckCode = (dependency) => `
 from importlib import util
 dep = '${dependency}'.replace('-', '_')
@@ -2770,13 +2899,13 @@ print(spec.origin)
 `;
 async function isInstalled(pythonPath, dependency, cwd) {
   try {
-    const { stdout } = await (0, import_execa.default)(
+    const { stdout } = await (0, import_execa2.default)(
       pythonPath,
       ["-c", makeDependencyCheckCode(dependency)],
       {
         stdio: "pipe",
         cwd,
-        env: { ...process.env, PYTHONPATH: (0, import_path.join)(cwd, resolveVendorDir()) }
+        env: { ...process.env, PYTHONPATH: (0, import_path2.join)(cwd, resolveVendorDir()) }
       }
     );
     return stdout.startsWith(cwd);
@@ -2793,13 +2922,13 @@ pkg_resources.require(dependencies)
 `;
 async function areRequirementsInstalled(pythonPath, requirementsPath, cwd) {
   try {
-    await (0, import_execa.default)(
+    await (0, import_execa2.default)(
       pythonPath,
       ["-c", makeRequirementsCheckCode(requirementsPath)],
       {
         stdio: "pipe",
         cwd,
-        env: { ...process.env, PYTHONPATH: (0, import_path.join)(cwd, resolveVendorDir()) }
+        env: { ...process.env, PYTHONPATH: (0, import_path2.join)(cwd, resolveVendorDir()) }
       }
     );
     return true;
@@ -2807,18 +2936,354 @@ async function areRequirementsInstalled(pythonPath, requirementsPath, cwd) {
     return false;
   }
 }
+async function runUvSync({
+  uvPath,
+  venvPath,
+  projectDir,
+  locked
+}) {
+  const args = ["sync", "--active", "--no-dev", "--link-mode", "copy"];
+  if (locked) {
+    args.push("--locked");
+  }
+  args.push("--no-editable");
+  await runUvCommand({
+    uvPath,
+    args,
+    cwd: projectDir,
+    venvPath
+  });
+}
+async function getSitePackagesDirs(pythonBin) {
+  const code = `
+import json
+import sysconfig
+paths = []
+for key in ("purelib", "platlib"):
+    candidate = sysconfig.get_path(key)
+    if candidate and candidate not in paths:
+        paths.append(candidate)
+print(json.dumps(paths))
+`.trim();
+  const { stdout } = await (0, import_execa2.default)(pythonBin, ["-c", code]);
+  try {
+    const parsed = JSON.parse(stdout);
+    if (Array.isArray(parsed)) {
+      return parsed.filter((p) => typeof p === "string");
+    }
+  } catch (err) {
+    (0, import_build_utils2.debug)("Failed to parse site-packages output", err);
+  }
+  return [];
+}
+async function getVenvSitePackagesDirs(venvPath) {
+  const pythonBin = getVenvPythonBin(venvPath);
+  return getSitePackagesDirs(pythonBin);
+}
 function resolveVendorDir() {
   const vendorDir = process.env.VERCEL_PYTHON_VENDOR_DIR || "_vendor";
   return vendorDir;
 }
+async function detectInstallSource({
+  workPath,
+  entryDirectory,
+  fsFiles
+}) {
+  const uvLockDir = findDir({
+    file: "uv.lock",
+    entryDirectory,
+    workPath,
+    fsFiles
+  });
+  const pyprojectDir = findDir({
+    file: "pyproject.toml",
+    entryDirectory,
+    workPath,
+    fsFiles
+  });
+  const pipfileLockDir = findDir({
+    file: "Pipfile.lock",
+    entryDirectory,
+    workPath,
+    fsFiles
+  });
+  const pipfileDir = findDir({
+    file: "Pipfile",
+    entryDirectory,
+    workPath,
+    fsFiles
+  });
+  const requirementsDir = findDir({
+    file: "requirements.txt",
+    entryDirectory,
+    workPath,
+    fsFiles
+  });
+  let manifestPath = null;
+  let manifestType = null;
+  if (uvLockDir && pyprojectDir) {
+    manifestType = "uv.lock";
+    manifestPath = (0, import_path2.join)(uvLockDir, "uv.lock");
+  } else if (pyprojectDir) {
+    manifestType = "pyproject.toml";
+    manifestPath = (0, import_path2.join)(pyprojectDir, "pyproject.toml");
+  } else if (pipfileLockDir) {
+    manifestType = "Pipfile.lock";
+    manifestPath = (0, import_path2.join)(pipfileLockDir, "Pipfile.lock");
+  } else if (pipfileDir) {
+    manifestType = "Pipfile";
+    manifestPath = (0, import_path2.join)(pipfileDir, "Pipfile");
+  } else if (requirementsDir) {
+    manifestType = "requirements.txt";
+    manifestPath = (0, import_path2.join)(requirementsDir, "requirements.txt");
+  }
+  let manifestContent;
+  if (manifestPath) {
+    try {
+      manifestContent = await import_fs2.default.promises.readFile(manifestPath, "utf8");
+    } catch (err) {
+      (0, import_build_utils2.debug)("Failed to read install manifest contents", err);
+    }
+  }
+  return { manifestPath, manifestType, manifestContent };
+}
+async function createPyprojectToml({
+  projectName,
+  pyprojectPath,
+  dependencies
+}) {
+  const requiresPython = ">=3.12";
+  const depsToml = dependencies.length > 0 ? [
+    "dependencies = [",
+    ...dependencies.map((dep) => `  "${dep}",`),
+    "]"
+  ].join("\n") : "dependencies = []";
+  const content = [
+    "[project]",
+    `name = "${projectName}"`,
+    'version = "0.1.0"',
+    `requires-python = "${requiresPython}"`,
+    "classifiers = [",
+    '  "Private :: Do Not Upload",',
+    "]",
+    depsToml,
+    ""
+  ].join("\n");
+  await import_fs2.default.promises.writeFile(pyprojectPath, content);
+}
+async function uvLock({
+  projectDir,
+  uvPath
+}) {
+  const args = ["lock"];
+  const pretty = `${uvPath} ${args.join(" ")}`;
+  (0, import_build_utils2.debug)(`Running "${pretty}" in ${projectDir}...`);
+  try {
+    await (0, import_execa2.default)(uvPath, args, { cwd: projectDir });
+  } catch (err) {
+    throw new Error(
+      `Failed to run "${pretty}": ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+}
+async function uvAddDependencies({
+  projectDir,
+  uvPath,
+  venvPath,
+  dependencies
+}) {
+  const toAdd = dependencies.filter(Boolean);
+  if (!toAdd.length)
+    return;
+  const args = ["add", "--active", ...toAdd];
+  const pretty = `${uvPath} ${args.join(" ")}`;
+  (0, import_build_utils2.debug)(`Running "${pretty}" in ${projectDir}...`);
+  await runUvCommand({ uvPath, args, cwd: projectDir, venvPath });
+}
+async function uvAddFromFile({
+  projectDir,
+  uvPath,
+  venvPath,
+  requirementsPath
+}) {
+  const args = ["add", "--active", "-r", requirementsPath];
+  const pretty = `${uvPath} ${args.join(" ")}`;
+  (0, import_build_utils2.debug)(`Running "${pretty}" in ${projectDir}...`);
+  await runUvCommand({ uvPath, args, cwd: projectDir, venvPath });
+}
+function getDependencyName(spec) {
+  const match = spec.match(/^[A-Za-z0-9_.-]+/);
+  return match ? match[0].toLowerCase() : spec.toLowerCase();
+}
+async function filterMissingRuntimeDependencies({
+  pyprojectPath,
+  runtimeDependencies
+}) {
+  let declared = [];
+  try {
+    const config = await (0, import_build_utils2.readConfigFile)(pyprojectPath);
+    declared = config?.project?.dependencies || [];
+  } catch (err) {
+    (0, import_build_utils2.debug)("Failed to parse pyproject.toml when filtering runtime deps", err);
+  }
+  const declaredNames = new Set(declared.map(getDependencyName));
+  return runtimeDependencies.filter((spec) => {
+    const name = getDependencyName(spec);
+    return !declaredNames.has(name);
+  });
+}
+function findUvLockUpwards(startDir, repoRootPath) {
+  const start = (0, import_path2.resolve)(startDir);
+  const base = repoRootPath ? (0, import_path2.resolve)(repoRootPath) : void 0;
+  for (const dir of (0, import_build_utils2.traverseUpDirectories)({ start, base })) {
+    const lockPath = (0, import_path2.join)(dir, "uv.lock");
+    const pyprojectPath = (0, import_path2.join)(dir, "pyproject.toml");
+    if (import_fs2.default.existsSync(lockPath) && import_fs2.default.existsSync(pyprojectPath)) {
+      return lockPath;
+    }
+  }
+  return null;
+}
+async function ensureUvProject({
+  workPath,
+  entryDirectory,
+  fsFiles,
+  repoRootPath,
+  pythonPath,
+  pipPath,
+  uvPath,
+  venvPath,
+  meta,
+  runtimeDependencies
+}) {
+  const installInfo = await detectInstallSource({
+    workPath,
+    entryDirectory,
+    fsFiles
+  });
+  const { manifestType, manifestPath } = installInfo;
+  let projectDir;
+  let pyprojectPath;
+  let lockPath = null;
+  if (manifestType === "uv.lock") {
+    if (!manifestPath) {
+      throw new Error("Expected uv.lock path to be resolved, but it was null");
+    }
+    projectDir = (0, import_path2.dirname)(manifestPath);
+    pyprojectPath = (0, import_path2.join)(projectDir, "pyproject.toml");
+    if (!import_fs2.default.existsSync(pyprojectPath)) {
+      throw new Error(
+        `Expected "pyproject.toml" next to "uv.lock" in "${projectDir}"`
+      );
+    }
+    lockPath = manifestPath;
+    console.log("Installing required dependencies from uv.lock...");
+  } else if (manifestType === "pyproject.toml") {
+    if (!manifestPath) {
+      throw new Error(
+        "Expected pyproject.toml path to be resolved, but it was null"
+      );
+    }
+    projectDir = (0, import_path2.dirname)(manifestPath);
+    pyprojectPath = manifestPath;
+    console.log("Installing required dependencies from pyproject.toml...");
+    const workspaceLock = findUvLockUpwards(projectDir, repoRootPath);
+    if (workspaceLock) {
+      lockPath = workspaceLock;
+    } else {
+      await uvLock({ projectDir, uvPath });
+    }
+  } else if (manifestType === "Pipfile.lock" || manifestType === "Pipfile") {
+    if (!manifestPath) {
+      throw new Error(
+        "Expected Pipfile/Pipfile.lock path to be resolved, but it was null"
+      );
+    }
+    projectDir = (0, import_path2.dirname)(manifestPath);
+    console.log(`Installing required dependencies from ${manifestType}...`);
+    const exportedReq = await exportRequirementsFromPipfile({
+      pythonPath,
+      pipPath,
+      uvPath,
+      projectDir,
+      meta
+    });
+    pyprojectPath = (0, import_path2.join)(projectDir, "pyproject.toml");
+    if (!import_fs2.default.existsSync(pyprojectPath)) {
+      await createPyprojectToml({
+        projectName: "app",
+        pyprojectPath,
+        dependencies: []
+      });
+    }
+    await uvAddFromFile({
+      projectDir,
+      uvPath,
+      venvPath,
+      requirementsPath: exportedReq
+    });
+  } else if (manifestType === "requirements.txt") {
+    if (!manifestPath) {
+      throw new Error(
+        "Expected requirements.txt path to be resolved, but it was null"
+      );
+    }
+    projectDir = (0, import_path2.dirname)(manifestPath);
+    pyprojectPath = (0, import_path2.join)(projectDir, "pyproject.toml");
+    console.log(
+      "Installing required dependencies from requirements.txt with uv..."
+    );
+    if (!import_fs2.default.existsSync(pyprojectPath)) {
+      await createPyprojectToml({
+        projectName: "app",
+        pyprojectPath,
+        dependencies: []
+      });
+    }
+    await uvAddFromFile({
+      projectDir,
+      uvPath,
+      venvPath,
+      requirementsPath: manifestPath
+    });
+  } else {
+    projectDir = workPath;
+    pyprojectPath = (0, import_path2.join)(projectDir, "pyproject.toml");
+    console.log(
+      "No Python manifest found; creating an empty pyproject.toml and uv.lock..."
+    );
+    await createPyprojectToml({
+      projectName: "app",
+      pyprojectPath,
+      dependencies: []
+    });
+    await uvLock({ projectDir, uvPath });
+  }
+  if (runtimeDependencies.length) {
+    const missingRuntimeDeps = await filterMissingRuntimeDependencies({
+      pyprojectPath,
+      runtimeDependencies
+    });
+    if (missingRuntimeDeps.length) {
+      await uvAddDependencies({
+        projectDir,
+        uvPath,
+        venvPath,
+        dependencies: missingRuntimeDeps
+      });
+    }
+  }
+  const resolvedLockPath = lockPath && import_fs2.default.existsSync(lockPath) ? lockPath : findUvLockUpwards(projectDir, repoRootPath) || (0, import_path2.join)(projectDir, "uv.lock");
+  return { projectDir, pyprojectPath, lockPath: resolvedLockPath };
+}
 async function getGlobalScriptsDir(pythonPath) {
   const code = `import sysconfig; print(sysconfig.get_path('scripts'))`;
   try {
-    const { stdout } = await (0, import_execa.default)(pythonPath, ["-c", code]);
+    const { stdout } = await (0, import_execa2.default)(pythonPath, ["-c", code]);
     const out = stdout.trim();
     return out || null;
   } catch (err) {
-    (0, import_build_utils.debug)("Failed to resolve Python global scripts directory", err);
+    (0, import_build_utils2.debug)("Failed to resolve Python global scripts directory", err);
     return null;
   }
 }
@@ -2828,16 +3293,16 @@ async function getUserScriptsDir(pythonPath) {
     " "
   );
   try {
-    const { stdout } = await (0, import_execa.default)(pythonPath, ["-c", code]);
+    const { stdout } = await (0, import_execa2.default)(pythonPath, ["-c", code]);
     const out = stdout.trim();
     return out || null;
   } catch (err) {
-    (0, import_build_utils.debug)("Failed to resolve Python user scripts directory", err);
+    (0, import_build_utils2.debug)("Failed to resolve Python user scripts directory", err);
     return null;
   }
 }
 async function pipInstall(pipPath, uvPath, workPath, args, targetDir) {
-  const target = targetDir ? (0, import_path.join)(targetDir, resolveVendorDir()) : resolveVendorDir();
+  const target = targetDir ? (0, import_path2.join)(targetDir, resolveVendorDir()) : resolveVendorDir();
   process.env.PIP_USER = "0";
   if (uvPath) {
     const uvArgs = [
@@ -2847,18 +3312,18 @@ async function pipInstall(pipPath, uvPath, workPath, args, targetDir) {
       "--no-cache-dir",
       "--target",
       target,
-      ...args
+      ...filterUnsafeUvPipArgs(args)
     ];
     const prettyUv = `${uvPath} ${uvArgs.join(" ")}`;
-    (0, import_build_utils.debug)(`Running "${prettyUv}"...`);
+    (0, import_build_utils2.debug)(`Running "${prettyUv}"...`);
     try {
-      await (0, import_execa.default)(uvPath, uvArgs, {
+      await (0, import_execa2.default)(uvPath, uvArgs, {
         cwd: workPath
       });
       return;
     } catch (err) {
       console.log(`Failed to run "${prettyUv}", falling back to pip`);
-      (0, import_build_utils.debug)(`error: ${err}`);
+      (0, import_build_utils2.debug)(`error: ${err}`);
     }
   }
   const cmdArgs = [
@@ -2871,14 +3336,14 @@ async function pipInstall(pipPath, uvPath, workPath, args, targetDir) {
     ...args
   ];
   const pretty = `${pipPath} ${cmdArgs.join(" ")}`;
-  (0, import_build_utils.debug)(`Running "${pretty}"...`);
+  (0, import_build_utils2.debug)(`Running "${pretty}"...`);
   try {
-    await (0, import_execa.default)(pipPath, cmdArgs, {
+    await (0, import_execa2.default)(pipPath, cmdArgs, {
       cwd: workPath
     });
   } catch (err) {
     console.log(`Failed to run "${pretty}"`);
-    (0, import_build_utils.debug)(`error: ${err}`);
+    (0, import_build_utils2.debug)(`error: ${err}`);
     throw err;
   }
 }
@@ -2889,38 +3354,38 @@ async function maybeFindUvBin(pythonPath) {
   try {
     const globalScriptsDir = await getGlobalScriptsDir(pythonPath);
     if (globalScriptsDir) {
-      const uvPath = (0, import_path.join)(globalScriptsDir, uvExec);
-      if (import_fs.default.existsSync(uvPath))
+      const uvPath = (0, import_path2.join)(globalScriptsDir, uvExec);
+      if (import_fs2.default.existsSync(uvPath))
         return uvPath;
     }
   } catch (err) {
-    (0, import_build_utils.debug)("Failed to resolve Python global scripts directory", err);
+    (0, import_build_utils2.debug)("Failed to resolve Python global scripts directory", err);
   }
   try {
     const userScriptsDir = await getUserScriptsDir(pythonPath);
     if (userScriptsDir) {
-      const uvPath = (0, import_path.join)(userScriptsDir, uvExec);
-      if (import_fs.default.existsSync(uvPath))
+      const uvPath = (0, import_path2.join)(userScriptsDir, uvExec);
+      if (import_fs2.default.existsSync(uvPath))
         return uvPath;
     }
   } catch (err) {
-    (0, import_build_utils.debug)("Failed to resolve Python user scripts directory", err);
+    (0, import_build_utils2.debug)("Failed to resolve Python user scripts directory", err);
   }
   try {
     const candidates = [];
-    if (!isWin) {
-      candidates.push((0, import_path.join)(import_os.default.homedir(), ".local", "bin", "uv"));
+    if (!isWin2) {
+      candidates.push((0, import_path2.join)(import_os.default.homedir(), ".local", "bin", "uv"));
       candidates.push("/usr/local/bin/uv");
       candidates.push("/opt/homebrew/bin/uv");
     } else {
       candidates.push("C:\\Users\\Public\\uv\\uv.exe");
     }
     for (const p of candidates) {
-      if (import_fs.default.existsSync(p))
+      if (import_fs2.default.existsSync(p))
         return p;
     }
   } catch (err) {
-    (0, import_build_utils.debug)("Failed to resolve uv fallback paths", err);
+    (0, import_build_utils2.debug)("Failed to resolve uv fallback paths", err);
   }
   return null;
 }
@@ -2930,7 +3395,7 @@ async function getUvBinaryOrInstall(pythonPath) {
     return uvBin;
   try {
     console.log("Installing uv...");
-    await (0, import_execa.default)(
+    await (0, import_execa2.default)(
       pythonPath,
       [
         "-m",
@@ -2968,7 +3433,7 @@ async function installRequirement({
 }) {
   const actualTargetDir = targetDir || workPath;
   if (meta.isDev && await isInstalled(pythonPath, dependency, actualTargetDir)) {
-    (0, import_build_utils.debug)(
+    (0, import_build_utils2.debug)(
       `Skipping ${dependency} dependency installation, already installed in ${actualTargetDir}`
     );
     return;
@@ -2988,7 +3453,7 @@ async function installRequirementsFile({
 }) {
   const actualTargetDir = targetDir || workPath;
   if (meta.isDev && await areRequirementsInstalled(pythonPath, filePath, actualTargetDir)) {
-    (0, import_build_utils.debug)(`Skipping requirements file installation, already installed`);
+    (0, import_build_utils2.debug)(`Skipping requirements file installation, already installed`);
     return;
   }
   await pipInstall(
@@ -2999,30 +3464,8 @@ async function installRequirementsFile({
     targetDir
   );
 }
-async function exportRequirementsFromUv(projectDir, uvPath, options = {}) {
-  const { locked = false } = options;
-  if (!uvPath) {
-    throw new Error("uv is not available to export requirements");
-  }
-  const args = ["export"];
-  if (locked) {
-    args.push("--frozen");
-  }
-  (0, import_build_utils.debug)(`Running "${uvPath} ${args.join(" ")}" in ${projectDir}...`);
-  let stdout;
-  try {
-    const { stdout: out } = await (0, import_execa.default)(uvPath, args, { cwd: projectDir });
-    stdout = out;
-  } catch (err) {
-    throw new Error(
-      `Failed to run "${uvPath} ${args.join(" ")}": ${err instanceof Error ? err.message : String(err)}`
-    );
-  }
-  const tmpDir = await import_fs.default.promises.mkdtemp((0, import_path.join)(import_os.default.tmpdir(), "vercel-uv-"));
-  const outPath = (0, import_path.join)(tmpDir, "requirements.uv.txt");
-  await import_fs.default.promises.writeFile(outPath, stdout);
-  (0, import_build_utils.debug)(`Exported requirements to ${outPath}`);
-  return outPath;
+function filterUnsafeUvPipArgs(args) {
+  return args.filter((arg) => arg !== "--no-warn-script-location");
 }
 async function exportRequirementsFromPipfile({
   pythonPath,
@@ -3031,8 +3474,8 @@ async function exportRequirementsFromPipfile({
   projectDir,
   meta
 }) {
-  const tempDir = await import_fs.default.promises.mkdtemp(
-    (0, import_path.join)(import_os.default.tmpdir(), "vercel-pipenv-")
+  const tempDir = await import_fs2.default.promises.mkdtemp(
+    (0, import_path2.join)(import_os.default.tmpdir(), "vercel-pipenv-")
   );
   await installRequirement({
     pythonPath,
@@ -3044,12 +3487,12 @@ async function exportRequirementsFromPipfile({
     args: ["--no-warn-script-location"],
     uvPath
   });
-  const tempVendorDir = (0, import_path.join)(tempDir, resolveVendorDir());
-  const convertCmd = isWin ? (0, import_path.join)(tempVendorDir, "Scripts", "pipfile2req.exe") : (0, import_path.join)(tempVendorDir, "bin", "pipfile2req");
-  (0, import_build_utils.debug)(`Running "${convertCmd}" in ${projectDir}...`);
+  const tempVendorDir = (0, import_path2.join)(tempDir, resolveVendorDir());
+  const convertCmd = isWin2 ? (0, import_path2.join)(tempVendorDir, "Scripts", "pipfile2req.exe") : (0, import_path2.join)(tempVendorDir, "bin", "pipfile2req");
+  (0, import_build_utils2.debug)(`Running "${convertCmd}" in ${projectDir}...`);
   let stdout;
   try {
-    const { stdout: out } = await (0, import_execa.default)(convertCmd, [], {
+    const { stdout: out } = await (0, import_execa2.default)(convertCmd, [], {
       cwd: projectDir,
       env: { ...process.env, PYTHONPATH: tempVendorDir }
     });
@@ -3059,17 +3502,46 @@ async function exportRequirementsFromPipfile({
       `Failed to run "${convertCmd}": ${err instanceof Error ? err.message : String(err)}`
     );
   }
-  const outPath = (0, import_path.join)(tempDir, "requirements.pipenv.txt");
-  await import_fs.default.promises.writeFile(outPath, stdout);
-  (0, import_build_utils.debug)(`Exported pipfile requirements to ${outPath}`);
+  const outPath = (0, import_path2.join)(tempDir, "requirements.pipenv.txt");
+  await import_fs2.default.promises.writeFile(outPath, stdout);
+  (0, import_build_utils2.debug)(`Exported pipfile requirements to ${outPath}`);
   return outPath;
 }
+async function mirrorSitePackagesIntoVendor({
+  venvPath,
+  vendorDirName
+}) {
+  const vendorFiles = {};
+  try {
+    const sitePackageDirs = await getVenvSitePackagesDirs(venvPath);
+    for (const dir of sitePackageDirs) {
+      if (!import_fs2.default.existsSync(dir))
+        continue;
+      const dirFiles = await (0, import_build_utils2.glob)("**", dir);
+      for (const relativePath of Object.keys(dirFiles)) {
+        if (relativePath.endsWith(".pyc") || relativePath.includes("__pycache__")) {
+          continue;
+        }
+        const srcFsPath = (0, import_path2.join)(dir, relativePath);
+        const bundlePath = (0, import_path2.join)(vendorDirName, relativePath).replace(
+          /\\/g,
+          "/"
+        );
+        vendorFiles[bundlePath] = new import_build_utils2.FileFsRef({ fsPath: srcFsPath });
+      }
+    }
+  } catch (err) {
+    console.log("Failed to collect site-packages from virtual environment");
+    throw err;
+  }
+  return vendorFiles;
+}
 
 // src/index.ts
-var import_build_utils6 = require("@vercel/build-utils");
+var import_build_utils8 = require("@vercel/build-utils");
 
 // src/version.ts
-var import_build_utils2 = require("@vercel/build-utils");
+var import_build_utils3 = require("@vercel/build-utils");
 var import_which2 = __toESM(require_lib());
 var allOptions = [
   {
@@ -3120,7 +3592,7 @@ function getLatestPythonVersion({
   }
   const selection = allOptions.find(isInstalled2);
   if (!selection) {
-    throw new import_build_utils2.NowBuildError({
+    throw new import_build_utils3.NowBuildError({
       code: "PYTHON_NOT_FOUND",
       link: "http://vercel.link/python-version",
       message: `Unable to find any supported Python versions.`
@@ -3128,6 +3600,81 @@ function getLatestPythonVersion({
   }
   return selection;
 }
+function parseVersionTuple(input) {
+  const cleaned = input.trim().replace(/\s+/g, "");
+  const m = cleaned.match(/^(\d+)(?:\.(\d+))?/);
+  if (!m)
+    return null;
+  const major = Number(m[1]);
+  const minor = m[2] !== void 0 ? Number(m[2]) : 0;
+  if (Number.isNaN(major) || Number.isNaN(minor))
+    return null;
+  return [major, minor];
+}
+function compareTuples(a, b) {
+  if (a[0] !== b[0])
+    return a[0] - b[0];
+  return a[1] - b[1];
+}
+function parseSpecifier(spec) {
+  const s = spec.trim();
+  const m = s.match(/^(<=|>=|==|!=|~=|<|>)\s*([0-9]+(?:\.[0-9]+)?)(?:\.\*)?$/) || // Bare version like "3.11" -> implied ==
+  s.match(/^()([0-9]+(?:\.[0-9]+)?)(?:\.\*)?$/);
+  if (!m)
+    return null;
+  const op = m[1] || "==";
+  const vt = parseVersionTuple(m[2]);
+  if (!vt)
+    return null;
+  return { op, ver: vt };
+}
+function satisfies(candidate, spec) {
+  const cmp = compareTuples(candidate, spec.ver);
+  switch (spec.op) {
+    case "==":
+      return cmp === 0;
+    case "!=":
+      return cmp !== 0;
+    case "<":
+      return cmp < 0;
+    case "<=":
+      return cmp <= 0;
+    case ">":
+      return cmp > 0;
+    case ">=":
+      return cmp >= 0;
+    case "~=": {
+      const lowerOk = cmp >= 0;
+      const upper = [spec.ver[0], spec.ver[1] + 1];
+      return lowerOk && compareTuples(candidate, upper) < 0;
+    }
+    default:
+      return false;
+  }
+}
+function selectFromRequiresPython(expr) {
+  const raw = expr.trim();
+  if (!raw)
+    return void 0;
+  const parts = raw.split(",").map((p) => p.trim()).filter(Boolean);
+  const specifiers = [];
+  for (const p of parts) {
+    const sp = parseSpecifier(p);
+    if (sp)
+      specifiers.push(sp);
+  }
+  if (specifiers.length === 0) {
+    return allOptions.find((o) => o.version === raw);
+  }
+  const matches = allOptions.filter((opt) => {
+    const vt = parseVersionTuple(opt.version);
+    return specifiers.every((sp) => satisfies(vt, sp));
+  });
+  if (matches.length === 0)
+    return void 0;
+  const installedMatch = matches.find(isInstalled2);
+  return installedMatch ?? matches[0];
+}
 function getSupportedPythonVersion({
   isDev,
   declaredPythonVersion
@@ -3138,10 +3685,15 @@ function getSupportedPythonVersion({
   let selection = getLatestPythonVersion({ isDev: false });
   if (declaredPythonVersion) {
     const { version: version2, source } = declaredPythonVersion;
-    const requested = allOptions.find((o) => o.version === version2);
+    let requested;
+    if (source === "pyproject.toml") {
+      requested = selectFromRequiresPython(version2);
+    } else {
+      requested = allOptions.find((o) => o.version === version2);
+    }
     if (requested) {
       if (isDiscontinued(requested)) {
-        throw new import_build_utils2.NowBuildError({
+        throw new import_build_utils3.NowBuildError({
           code: "BUILD_UTILS_PYTHON_VERSION_DISCONTINUED",
           link: "http://vercel.link/python-version",
           message: `Python version "${requested.version}" detected in ${source} is discontinued and must be upgraded.`
@@ -3172,7 +3724,7 @@ function getSupportedPythonVersion({
     );
   }
   if (isDiscontinued(selection)) {
-    throw new import_build_utils2.NowBuildError({
+    throw new import_build_utils3.NowBuildError({
       code: "BUILD_UTILS_PYTHON_VERSION_DISCONTINUED",
       link: "http://vercel.link/python-version",
       message: `Python version "${selection.version}" declared in project configuration is discontinued and must be upgraded.`
@@ -3199,18 +3751,19 @@ function isInstalled2({ pipPath, pythonPath }) {
 var import_child_process = require("child_process");
 var import_fs4 = require("fs");
 var import_path4 = require("path");
-var import_build_utils4 = require("@vercel/build-utils");
+var import_build_utils6 = require("@vercel/build-utils");
 
 // src/entrypoint.ts
-var import_fs2 = __toESM(require("fs"));
-var import_path2 = require("path");
-var import_build_utils3 = require("@vercel/build-utils");
+var import_fs3 = __toESM(require("fs"));
+var import_path3 = require("path");
+var import_build_utils4 = require("@vercel/build-utils");
+var import_build_utils5 = require("@vercel/build-utils");
 var FASTAPI_ENTRYPOINT_FILENAMES = ["app", "index", "server", "main"];
-var FASTAPI_ENTRYPOINT_DIRS = ["", "src", "app"];
+var FASTAPI_ENTRYPOINT_DIRS = ["", "src", "app", "api"];
 var FASTAPI_CONTENT_REGEX = /(from\s+fastapi\s+import\s+FastAPI|import\s+fastapi|FastAPI\s*\()/;
 var FASTAPI_CANDIDATE_ENTRYPOINTS = FASTAPI_ENTRYPOINT_FILENAMES.flatMap(
   (filename) => FASTAPI_ENTRYPOINT_DIRS.map(
-    (dir) => import_path2.posix.join(dir, `${filename}.py`)
+    (dir) => import_path3.posix.join(dir, `${filename}.py`)
   )
 );
 function isFastapiEntrypoint(file) {
@@ -3218,18 +3771,18 @@ function isFastapiEntrypoint(file) {
     const fsPath = file.fsPath;
     if (!fsPath)
       return false;
-    const contents = import_fs2.default.readFileSync(fsPath, "utf8");
+    const contents = import_fs3.default.readFileSync(fsPath, "utf8");
     return FASTAPI_CONTENT_REGEX.test(contents);
   } catch {
     return false;
   }
 }
 var FLASK_ENTRYPOINT_FILENAMES = ["app", "index", "server", "main"];
-var FLASK_ENTRYPOINT_DIRS = ["", "src", "app"];
+var FLASK_ENTRYPOINT_DIRS = ["", "src", "app", "api"];
 var FLASK_CONTENT_REGEX = /(from\s+flask\s+import\s+Flask|import\s+flask|Flask\s*\()/;
 var FLASK_CANDIDATE_ENTRYPOINTS = FLASK_ENTRYPOINT_FILENAMES.flatMap(
   (filename) => FLASK_ENTRYPOINT_DIRS.map(
-    (dir) => import_path2.posix.join(dir, `${filename}.py`)
+    (dir) => import_path3.posix.join(dir, `${filename}.py`)
   )
 );
 function isFlaskEntrypoint(file) {
@@ -3237,7 +3790,7 @@ function isFlaskEntrypoint(file) {
     const fsPath = file.fsPath;
     if (!fsPath)
       return false;
-    const contents = import_fs2.default.readFileSync(fsPath, "utf8");
+    const contents = import_fs3.default.readFileSync(fsPath, "utf8");
     return FLASK_CONTENT_REGEX.test(contents);
   } catch {
     return false;
@@ -3246,7 +3799,7 @@ function isFlaskEntrypoint(file) {
 async function detectFlaskEntrypoint(workPath, configuredEntrypoint) {
   const entry = configuredEntrypoint.endsWith(".py") ? configuredEntrypoint : `${configuredEntrypoint}.py`;
   try {
-    const fsFiles = await (0, import_build_utils3.glob)("**", workPath);
+    const fsFiles = await (0, import_build_utils4.glob)("**", workPath);
     if (fsFiles[entry])
       return entry;
     const candidates = FLASK_CANDIDATE_ENTRYPOINTS.filter(
@@ -3256,19 +3809,19 @@ async function detectFlaskEntrypoint(workPath, configuredEntrypoint) {
       const flaskEntrypoint = candidates.find(
         (c) => isFlaskEntrypoint(fsFiles[c])
       ) || candidates[0];
-      (0, import_build_utils3.debug)(`Detected Flask entrypoint: ${flaskEntrypoint}`);
+      (0, import_build_utils4.debug)(`Detected Flask entrypoint: ${flaskEntrypoint}`);
       return flaskEntrypoint;
     }
     return null;
   } catch {
-    (0, import_build_utils3.debug)("Failed to discover entrypoint for Flask");
+    (0, import_build_utils4.debug)("Failed to discover entrypoint for Flask");
     return null;
   }
 }
 async function detectFastapiEntrypoint(workPath, configuredEntrypoint) {
   const entry = configuredEntrypoint.endsWith(".py") ? configuredEntrypoint : `${configuredEntrypoint}.py`;
   try {
-    const fsFiles = await (0, import_build_utils3.glob)("**", workPath);
+    const fsFiles = await (0, import_build_utils4.glob)("**", workPath);
     if (fsFiles[entry])
       return entry;
     const candidates = FASTAPI_CANDIDATE_ENTRYPOINTS.filter(
@@ -3278,38 +3831,51 @@ async function detectFastapiEntrypoint(workPath, configuredEntrypoint) {
       const fastapiEntrypoint = candidates.find(
         (c) => isFastapiEntrypoint(fsFiles[c])
       ) || candidates[0];
-      (0, import_build_utils3.debug)(`Detected FastAPI entrypoint: ${fastapiEntrypoint}`);
+      (0, import_build_utils4.debug)(`Detected FastAPI entrypoint: ${fastapiEntrypoint}`);
       return fastapiEntrypoint;
     }
     return null;
   } catch {
-    (0, import_build_utils3.debug)("Failed to discover entrypoint for FastAPI");
+    (0, import_build_utils4.debug)("Failed to discover entrypoint for FastAPI");
     return null;
   }
 }
-
-// src/utils.ts
-var import_fs3 = __toESM(require("fs"));
-var import_path3 = require("path");
-var isInVirtualEnv = () => {
-  return process.env.VIRTUAL_ENV;
-};
-function useVirtualEnv(workPath, env, systemPython) {
-  const venvDirs = [".venv", "venv"];
-  let pythonCmd = systemPython;
-  for (const venv of venvDirs) {
-    const venvRoot = (0, import_path3.join)(workPath, venv);
-    const binDir = process.platform === "win32" ? (0, import_path3.join)(venvRoot, "Scripts") : (0, import_path3.join)(venvRoot, "bin");
-    const candidates = process.platform === "win32" ? [(0, import_path3.join)(binDir, "python.exe"), (0, import_path3.join)(binDir, "python")] : [(0, import_path3.join)(binDir, "python3"), (0, import_path3.join)(binDir, "python")];
-    const found = candidates.find((p) => import_fs3.default.existsSync(p));
-    if (found) {
-      pythonCmd = found;
-      env.VIRTUAL_ENV = venvRoot;
-      env.PATH = `${binDir}${import_path3.delimiter}${env.PATH || ""}`;
-      return { pythonCmd, venvRoot };
+async function getPyprojectEntrypoint(workPath) {
+  const pyprojectData = await (0, import_build_utils5.readConfigFile)((0, import_path3.join)(workPath, "pyproject.toml"));
+  if (!pyprojectData)
+    return null;
+  const scripts = pyprojectData.project?.scripts;
+  const appScript = scripts?.app;
+  if (typeof appScript !== "string")
+    return null;
+  const match = appScript.match(/([A-Za-z_][\w.]*)\s*:\s*([A-Za-z_][\w]*)/);
+  if (!match)
+    return null;
+  const modulePath = match[1];
+  const relPath = modulePath.replace(/\./g, "/");
+  try {
+    const fsFiles = await (0, import_build_utils4.glob)("**", workPath);
+    const candidates = [`${relPath}.py`, `${relPath}/__init__.py`];
+    for (const candidate of candidates) {
+      if (fsFiles[candidate])
+        return candidate;
     }
+    return null;
+  } catch {
+    (0, import_build_utils4.debug)("Failed to discover Python entrypoint from pyproject.toml");
+    return null;
   }
-  return { pythonCmd };
+}
+async function detectPythonEntrypoint(framework, workPath, configuredEntrypoint) {
+  let entrypoint = null;
+  if (framework === "fastapi") {
+    entrypoint = await detectFastapiEntrypoint(workPath, configuredEntrypoint);
+  } else if (framework === "flask") {
+    entrypoint = await detectFlaskEntrypoint(workPath, configuredEntrypoint);
+  }
+  if (entrypoint)
+    return entrypoint;
+  return await getPyprojectEntrypoint(workPath);
 }
 
 // src/start-dev-server.ts
@@ -3355,12 +3921,12 @@ function installGlobalCleanupHandlers() {
       try {
         process.kill(info.pid, "SIGTERM");
       } catch (err) {
-        (0, import_build_utils4.debug)(`Error sending SIGTERM to ${info.pid}: ${err}`);
+        (0, import_build_utils6.debug)(`Error sending SIGTERM to ${info.pid}: ${err}`);
       }
       try {
         process.kill(info.pid, "SIGKILL");
       } catch (err) {
-        (0, import_build_utils4.debug)(`Error sending SIGKILL to ${info.pid}: ${err}`);
+        (0, import_build_utils6.debug)(`Error sending SIGKILL to ${info.pid}: ${err}`);
       }
       PERSISTENT_SERVERS.delete(key);
     }
@@ -3368,7 +3934,7 @@ function installGlobalCleanupHandlers() {
       try {
         restoreWarnings();
       } catch (err) {
-        (0, import_build_utils4.debug)(`Error restoring warnings: ${err}`);
+        (0, import_build_utils6.debug)(`Error restoring warnings: ${err}`);
       }
       restoreWarnings = null;
     }
@@ -3394,10 +3960,10 @@ function createDevAsgiShim(workPath, modulePath) {
     const template = (0, import_fs4.readFileSync)(templatePath, "utf8");
     const shimSource = template.replace(/__VC_DEV_MODULE_PATH__/g, modulePath);
     (0, import_fs4.writeFileSync)(shimPath, shimSource, "utf8");
-    (0, import_build_utils4.debug)(`Prepared Python dev static shim at ${shimPath}`);
+    (0, import_build_utils6.debug)(`Prepared Python dev static shim at ${shimPath}`);
     return ASGI_SHIM_MODULE;
   } catch (err) {
-    (0, import_build_utils4.debug)(`Failed to prepare dev static shim: ${err?.message || err}`);
+    (0, import_build_utils6.debug)(`Failed to prepare dev static shim: ${err?.message || err}`);
     return null;
   }
 }
@@ -3410,10 +3976,10 @@ function createDevWsgiShim(workPath, modulePath) {
     const template = (0, import_fs4.readFileSync)(templatePath, "utf8");
     const shimSource = template.replace(/__VC_DEV_MODULE_PATH__/g, modulePath);
     (0, import_fs4.writeFileSync)(shimPath, shimSource, "utf8");
-    (0, import_build_utils4.debug)(`Prepared Python dev WSGI shim at ${shimPath}`);
+    (0, import_build_utils6.debug)(`Prepared Python dev WSGI shim at ${shimPath}`);
     return WSGI_SHIM_MODULE;
   } catch (err) {
-    (0, import_build_utils4.debug)(`Failed to prepare dev WSGI shim: ${err?.message || err}`);
+    (0, import_build_utils6.debug)(`Failed to prepare dev WSGI shim: ${err?.message || err}`);
     return null;
   }
 }
@@ -3426,26 +3992,19 @@ var startDevServer = async (opts) => {
   if (!restoreWarnings)
     restoreWarnings = silenceNodeWarnings();
   installGlobalCleanupHandlers();
-  let entry = null;
-  if (framework === "fastapi") {
-    const detectedFastapi = await detectFastapiEntrypoint(
-      workPath,
-      rawEntrypoint
-    );
-    if (!detectedFastapi) {
-      throw new Error(
-        `No FastAPI entrypoint found. Searched for: ${FASTAPI_CANDIDATE_ENTRYPOINTS.join(", ")}`
-      );
-    }
-    entry = detectedFastapi;
-  } else {
-    const detectedFlask = await detectFlaskEntrypoint(workPath, rawEntrypoint);
-    if (!detectedFlask) {
-      throw new Error(
-        `No Flask entrypoint found. Searched for: ${FLASK_CANDIDATE_ENTRYPOINTS.join(", ")}`
-      );
-    }
-    entry = detectedFlask;
+  const entry = await detectPythonEntrypoint(
+    framework,
+    workPath,
+    rawEntrypoint
+  );
+  if (!entry) {
+    const searched = framework === "fastapi" ? FASTAPI_CANDIDATE_ENTRYPOINTS.join(", ") : FLASK_CANDIDATE_ENTRYPOINTS.join(", ");
+    throw new import_build_utils6.NowBuildError({
+      code: "PYTHON_ENTRYPOINT_NOT_FOUND",
+      message: `No ${framework} entrypoint found. Add an 'app' script in pyproject.toml or define an entrypoint in one of: ${searched}.`,
+      link: `https://vercel.com/docs/frameworks/backend/${framework?.toLowerCase()}#exporting-the-${framework?.toLowerCase()}-application`,
+      action: "Learn More"
+    });
   }
   const modulePath = entry.replace(/\.py$/i, "").replace(/[\\/]/g, ".");
   const env = { ...process.env, ...meta.env || {} };
@@ -3477,20 +4036,20 @@ var startDevServer = async (opts) => {
   let resolveChildReady;
   let rejectChildReady;
   const childReady = new Promise(
-    (resolve, reject) => {
-      resolveChildReady = resolve;
+    (resolve2, reject) => {
+      resolveChildReady = resolve2;
       rejectChildReady = reject;
     }
   );
   PENDING_STARTS.set(serverKey, childReady);
   try {
-    await new Promise((resolve, reject) => {
+    await new Promise((resolve2, reject) => {
       let resolved = false;
       const { pythonPath: systemPython } = getLatestPythonVersion(meta);
       let pythonCmd = systemPython;
       const venv = isInVirtualEnv();
       if (venv) {
-        (0, import_build_utils4.debug)(`Running in virtualenv at ${venv}`);
+        (0, import_build_utils6.debug)(`Running in virtualenv at ${venv}`);
       } else {
         const { pythonCmd: venvPythonCmd, venvRoot } = useVirtualEnv(
           workPath,
@@ -3499,9 +4058,9 @@ var startDevServer = async (opts) => {
         );
         pythonCmd = venvPythonCmd;
         if (venvRoot) {
-          (0, import_build_utils4.debug)(`Using virtualenv at ${venvRoot}`);
+          (0, import_build_utils6.debug)(`Using virtualenv at ${venvRoot}`);
         } else {
-          (0, import_build_utils4.debug)("No virtualenv found");
+          (0, import_build_utils6.debug)("No virtualenv found");
           try {
             const yellow = "\x1B[33m";
             const reset = "\x1B[0m";
@@ -3524,7 +4083,7 @@ If you are using a virtual environment, activate it before running "vercel dev",
         }
         const moduleToRun = devShimModule || modulePath;
         const argv = ["-u", "-m", moduleToRun];
-        (0, import_build_utils4.debug)(`Starting ASGI dev server: ${pythonCmd} ${argv.join(" ")}`);
+        (0, import_build_utils6.debug)(`Starting ASGI dev server: ${pythonCmd} ${argv.join(" ")}`);
         const child = (0, import_child_process.spawn)(pythonCmd, argv, {
           cwd: workPath,
           env,
@@ -3572,7 +4131,7 @@ If you are using a virtual environment, activate it before running "vercel dev",
               child.stderr?.removeListener("data", onDetect);
               const port2 = Number(portMatch[1]);
               resolveChildReady({ port: port2, pid: child.pid });
-              resolve();
+              resolve2();
             }
           }
         };
@@ -3602,7 +4161,7 @@ If you are using a virtual environment, activate it before running "vercel dev",
         }
         const moduleToRun = devShimModule || modulePath;
         const argv = ["-u", "-m", moduleToRun];
-        (0, import_build_utils4.debug)(`Starting Flask dev server: ${pythonCmd} ${argv.join(" ")}`);
+        (0, import_build_utils6.debug)(`Starting Flask dev server: ${pythonCmd} ${argv.join(" ")}`);
         const child = (0, import_child_process.spawn)(pythonCmd, argv, {
           cwd: workPath,
           env,
@@ -3649,7 +4208,7 @@ If you are using a virtual environment, activate it before running "vercel dev",
               child.stderr?.removeListener("data", onDetect);
               const port2 = Number(portMatch[1]);
               resolveChildReady({ port: port2, pid: child.pid });
-              resolve();
+              resolve2();
             }
           }
         };
@@ -3692,44 +4251,34 @@ If you are using a virtual environment, activate it before running "vercel dev",
 var readFile = (0, import_util.promisify)(import_fs5.default.readFile);
 var writeFile = (0, import_util.promisify)(import_fs5.default.writeFile);
 var version = 3;
-function findDir({
-  file,
-  entryDirectory,
-  workPath,
-  fsFiles
-}) {
-  if (fsFiles[(0, import_path5.join)(entryDirectory, file)]) {
-    return (0, import_path5.join)(workPath, entryDirectory);
-  }
-  if (fsFiles[file]) {
-    return workPath;
-  }
-  return null;
-}
 async function downloadFilesInWorkPath({
   entrypoint,
   workPath,
   files,
   meta = {}
 }) {
-  (0, import_build_utils5.debug)("Downloading user files...");
-  let downloadedFiles = await (0, import_build_utils5.download)(files, workPath, meta);
+  (0, import_build_utils7.debug)("Downloading user files...");
+  let downloadedFiles = await (0, import_build_utils7.download)(files, workPath, meta);
   if (meta.isDev) {
     const { devCacheDir = (0, import_path5.join)(workPath, ".now", "cache") } = meta;
     const destCache = (0, import_path5.join)(devCacheDir, (0, import_path5.basename)(entrypoint, ".py"));
-    await (0, import_build_utils5.download)(downloadedFiles, destCache);
-    downloadedFiles = await (0, import_build_utils5.glob)("**", destCache);
+    await (0, import_build_utils7.download)(downloadedFiles, destCache);
+    downloadedFiles = await (0, import_build_utils7.glob)("**", destCache);
     workPath = destCache;
   }
   return workPath;
 }
 var build = async ({
   workPath,
+  repoRootPath,
   files: originalFiles,
   entrypoint,
   meta = {},
   config
 }) => {
+  const framework = config?.framework;
+  let spawnEnv;
+  let projectInstallCommand;
   workPath = await downloadFilesInWorkPath({
     workPath,
     files: originalFiles,
@@ -3745,73 +4294,96 @@ var build = async ({
     console.log('Failed to create "setup.cfg" file');
     throw err;
   }
-  let fsFiles = await (0, import_build_utils5.glob)("**", workPath);
-  if (!fsFiles[entrypoint] && config?.framework === "fastapi") {
-    const detected = await detectFastapiEntrypoint(workPath, entrypoint);
-    if (detected) {
-      (0, import_build_utils5.debug)(
-        `Resolved Python entrypoint to "${detected}" (configured "${entrypoint}" not found).`
-      );
-      entrypoint = detected;
-    } else {
-      const searchedList = FASTAPI_CANDIDATE_ENTRYPOINTS.join(", ");
-      throw new import_build_utils5.NowBuildError({
-        code: "FASTAPI_ENTRYPOINT_NOT_FOUND",
-        message: `No FastAPI entrypoint found. Searched for: ${searchedList}`
+  if (framework === "fastapi" || framework === "flask") {
+    const {
+      cliType,
+      lockfileVersion,
+      packageJsonPackageManager,
+      turboSupportsCorepackHome
+    } = await (0, import_build_utils7.scanParentDirs)(workPath, true);
+    spawnEnv = (0, import_build_utils7.getEnvForPackageManager)({
+      cliType,
+      lockfileVersion,
+      packageJsonPackageManager,
+      env: process.env,
+      turboSupportsCorepackHome,
+      projectCreatedAt: config?.projectSettings?.createdAt
+    });
+    const installCommand = config?.projectSettings?.installCommand;
+    if (typeof installCommand === "string") {
+      const trimmed = installCommand.trim();
+      if (trimmed) {
+        projectInstallCommand = trimmed;
+      } else {
+        console.log('Skipping "install" command...');
+      }
+    }
+    const projectBuildCommand = config?.projectSettings?.buildCommand ?? // fallback if provided directly on config (some callers set this)
+    config?.buildCommand;
+    if (projectBuildCommand) {
+      console.log(`Running "${projectBuildCommand}"`);
+      await (0, import_build_utils7.execCommand)(projectBuildCommand, {
+        env: spawnEnv,
+        cwd: workPath
       });
+    } else {
+      await runPyprojectScript(
+        workPath,
+        ["vercel-build", "now-build", "build"],
+        spawnEnv
+      );
     }
-  } else if (!fsFiles[entrypoint] && config?.framework === "flask") {
-    const detected = await detectFlaskEntrypoint(workPath, entrypoint);
+  }
+  let fsFiles = await (0, import_build_utils7.glob)("**", workPath);
+  if ((framework === "fastapi" || framework === "flask") && (!fsFiles[entrypoint] || !entrypoint.endsWith(".py"))) {
+    const detected = await detectPythonEntrypoint(
+      config.framework,
+      workPath,
+      entrypoint
+    );
     if (detected) {
-      (0, import_build_utils5.debug)(
+      (0, import_build_utils7.debug)(
         `Resolved Python entrypoint to "${detected}" (configured "${entrypoint}" not found).`
       );
       entrypoint = detected;
     } else {
-      const searchedList = FLASK_CANDIDATE_ENTRYPOINTS.join(", ");
-      throw new import_build_utils5.NowBuildError({
-        code: "FLASK_ENTRYPOINT_NOT_FOUND",
-        message: `No Flask entrypoint found. Searched for: ${searchedList}`
+      const searchedList = framework === "fastapi" ? FASTAPI_CANDIDATE_ENTRYPOINTS.join(", ") : FLASK_CANDIDATE_ENTRYPOINTS.join(", ");
+      throw 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"
       });
     }
   }
   const entryDirectory = (0, import_path5.dirname)(entrypoint);
-  const hasReqLocal = !!fsFiles[(0, import_path5.join)(entryDirectory, "requirements.txt")];
-  const hasReqGlobal = !!fsFiles["requirements.txt"];
-  const uvLockDir = findDir({
-    file: "uv.lock",
+  const pyprojectDir = findDir({
+    file: "pyproject.toml",
     entryDirectory,
     workPath,
     fsFiles
   });
-  const pyprojectDir = findDir({
-    file: "pyproject.toml",
+  const pipfileLockDir = findDir({
+    file: "Pipfile.lock",
     entryDirectory,
     workPath,
     fsFiles
   });
-  const pipfileLockDir = fsFiles[(0, import_path5.join)(entryDirectory, "Pipfile.lock")] ? (0, import_path5.join)(workPath, entryDirectory) : fsFiles["Pipfile.lock"] ? workPath : null;
-  const pipfileDir = fsFiles[(0, import_path5.join)(entryDirectory, "Pipfile")] ? (0, import_path5.join)(workPath, entryDirectory) : fsFiles["Pipfile"] ? workPath : null;
   let declaredPythonVersion;
   if (pyprojectDir) {
     let requiresPython;
     try {
-      const pyproject = await (0, import_build_utils6.readConfigFile)((0, import_path5.join)(pyprojectDir, "pyproject.toml"));
+      const pyproject = await (0, import_build_utils8.readConfigFile)((0, import_path5.join)(pyprojectDir, "pyproject.toml"));
       requiresPython = pyproject?.project?.["requires-python"];
     } catch (err) {
-      (0, import_build_utils5.debug)("Failed to parse pyproject.toml", err);
-    }
-    const VERSION_REGEX = /\b\d+\.\d+\b/;
-    const exact = requiresPython?.trim().match(VERSION_REGEX)?.[0];
-    if (exact) {
-      declaredPythonVersion = { version: exact, source: "pyproject.toml" };
-      (0, import_build_utils5.debug)(
-        `Found Python version ${exact} in pyproject.toml (requires-python: "${requiresPython}")`
-      );
-    } else if (requiresPython) {
-      (0, import_build_utils5.debug)(
-        `Could not parse Python version from pyproject.toml requires-python: "${requiresPython}"`
-      );
+      (0, import_build_utils7.debug)("Failed to parse pyproject.toml", err);
+    }
+    if (typeof requiresPython === "string" && requiresPython.trim()) {
+      declaredPythonVersion = {
+        version: requiresPython.trim(),
+        source: "pyproject.toml"
+      };
+      (0, import_build_utils7.debug)(`Found requires-python "${requiresPython}" in pyproject.toml`);
     }
   } else if (pipfileLockDir) {
     let lock = {};
@@ -3819,7 +4391,7 @@ var build = async ({
       const json = await readFile((0, import_path5.join)(pipfileLockDir, "Pipfile.lock"), "utf8");
       lock = JSON.parse(json);
     } catch (err) {
-      throw new import_build_utils5.NowBuildError({
+      throw new import_build_utils7.NowBuildError({
         code: "INVALID_PIPFILE_LOCK",
         message: "Unable to parse Pipfile.lock"
       });
@@ -3827,167 +4399,84 @@ var build = async ({
     const pyFromLock = lock?._meta?.requires?.python_version;
     if (pyFromLock) {
       declaredPythonVersion = { version: pyFromLock, source: "Pipfile.lock" };
-      (0, import_build_utils5.debug)(`Found Python version ${pyFromLock} in Pipfile.lock`);
+      (0, import_build_utils7.debug)(`Found Python version ${pyFromLock} in Pipfile.lock`);
     }
   }
   const pythonVersion = getSupportedPythonVersion({
     isDev: meta.isDev,
     declaredPythonVersion
   });
-  fsFiles = await (0, import_build_utils5.glob)("**", workPath);
-  const requirementsTxt = (0, import_path5.join)(entryDirectory, "requirements.txt");
-  const vendorBaseDir = (0, import_path5.join)(
-    workPath,
-    ".vercel",
-    "python",
-    `py${pythonVersion.version}`,
-    entryDirectory
-  );
-  try {
-    await import_fs5.default.promises.mkdir(vendorBaseDir, { recursive: true });
-  } catch (err) {
-    console.log("Failed to create vendor cache directory");
-    throw err;
-  }
-  let installationSource;
-  if (uvLockDir && pyprojectDir) {
-    installationSource = "uv.lock";
-  } else if (pyprojectDir) {
-    installationSource = "pyproject.toml";
-  } else if (pipfileLockDir) {
-    installationSource = "Pipfile.lock";
-  } else if (pipfileDir) {
-    installationSource = "Pipfile";
-  } else if (fsFiles[requirementsTxt] || fsFiles["requirements.txt"]) {
-    installationSource = "requirements.txt";
-  }
-  if (installationSource) {
-    console.log(
-      `Installing required dependencies from ${installationSource}...`
-    );
-  } else {
-    console.log("Installing required dependencies...");
-  }
-  let uvPath = null;
-  try {
-    uvPath = await getUvBinaryOrInstall(pythonVersion.pythonPath);
-    console.log(`Using uv at "${uvPath}"`);
-  } catch (err) {
-    if (uvLockDir || pyprojectDir && !hasReqLocal && !hasReqGlobal) {
-      console.log("Failed to install uv");
-      throw new Error(
-        `uv is required for this project but failed to install: ${err instanceof Error ? err.message : String(err)}`
-      );
-    }
-    (0, import_build_utils5.debug)("Failed to install uv", err);
-  }
-  await installRequirement({
+  fsFiles = await (0, import_build_utils7.glob)("**", workPath);
+  const venvPath = (0, import_path5.join)(workPath, ".vercel", "python", ".venv");
+  await ensureVenv({
     pythonPath: pythonVersion.pythonPath,
-    pipPath: pythonVersion.pipPath,
-    uvPath,
-    dependency: "werkzeug",
-    version: "1.0.1",
-    workPath,
-    targetDir: vendorBaseDir,
-    meta
+    venvPath
   });
-  let installedFromProjectFiles = false;
-  if (uvLockDir) {
-    (0, import_build_utils5.debug)('Found "uv.lock"');
-    if (pyprojectDir) {
-      const exportedReq = await exportRequirementsFromUv(pyprojectDir, uvPath, {
-        locked: true
-      });
-      await installRequirementsFile({
-        pythonPath: pythonVersion.pythonPath,
-        pipPath: pythonVersion.pipPath,
-        uvPath,
-        filePath: exportedReq,
+  const hasCustomInstallCommand = (framework === "fastapi" || framework === "flask") && !!projectInstallCommand;
+  if (hasCustomInstallCommand) {
+    const baseEnv = spawnEnv || process.env;
+    const pythonEnv = createVenvEnv(venvPath, baseEnv);
+    pythonEnv.VERCEL_PYTHON_VENV_PATH = venvPath;
+    const installCommand = projectInstallCommand;
+    console.log(`Running "install" command: \`${installCommand}\`...`);
+    await (0, import_build_utils7.execCommand)(installCommand, {
+      env: pythonEnv,
+      cwd: workPath
+    });
+  } else {
+    let ranPyprojectInstall = false;
+    if (framework === "fastapi" || framework === "flask") {
+      const baseEnv = spawnEnv || process.env;
+      const pythonEnv = createVenvEnv(venvPath, baseEnv);
+      pythonEnv.VERCEL_PYTHON_VENV_PATH = venvPath;
+      ranPyprojectInstall = await runPyprojectScript(
         workPath,
-        targetDir: vendorBaseDir,
-        meta
-      });
-      installedFromProjectFiles = true;
-    } else {
-      (0, import_build_utils5.debug)('Skipping uv export because "pyproject.toml" was not found');
-    }
-  } else if (pyprojectDir) {
-    (0, import_build_utils5.debug)('Found "pyproject.toml"');
-    if (hasReqLocal || hasReqGlobal) {
-      console.log(
-        "Detected both pyproject.toml and requirements.txt but no lockfile; using pyproject.toml"
+        ["vercel-install", "now-install", "install"],
+        pythonEnv,
+        /* useUserVirtualEnv */
+        false
       );
     }
-    const exportedReq = await exportRequirementsFromUv(pyprojectDir, uvPath, {
-      locked: false
-    });
-    await installRequirementsFile({
-      pythonPath: pythonVersion.pythonPath,
-      pipPath: pythonVersion.pipPath,
-      uvPath,
-      filePath: exportedReq,
-      workPath,
-      targetDir: vendorBaseDir,
-      meta
-    });
-    installedFromProjectFiles = true;
-  } else if (pipfileLockDir || pipfileDir) {
-    (0, import_build_utils5.debug)(`Found ${pipfileLockDir ? '"Pipfile.lock"' : '"Pipfile"'}`);
-    if (hasReqLocal || hasReqGlobal) {
-      (0, import_build_utils5.debug)('Skipping Pipfile export because "requirements.txt" exists');
-    } else {
-      const exportedReq = await exportRequirementsFromPipfile({
+    if (!ranPyprojectInstall) {
+      let uvPath;
+      try {
+        uvPath = await getUvBinaryOrInstall(pythonVersion.pythonPath);
+        console.log(`Using uv at "${uvPath}"`);
+      } catch (err) {
+        console.log("Failed to install or locate uv");
+        throw new Error(
+          `uv is required for this project but failed to install: ${err instanceof Error ? err.message : String(err)}`
+        );
+      }
+      const runtimeDependencies = framework === "flask" ? ["werkzeug>=1.0.1"] : ["werkzeug>=1.0.1", "uvicorn>=0.24"];
+      const { projectDir } = await ensureUvProject({
+        workPath,
+        entryDirectory,
+        fsFiles,
+        repoRootPath,
         pythonPath: pythonVersion.pythonPath,
         pipPath: pythonVersion.pipPath,
         uvPath,
-        projectDir: pipfileLockDir || pipfileDir,
-        meta
+        venvPath,
+        meta,
+        runtimeDependencies
       });
-      await installRequirementsFile({
-        pythonPath: pythonVersion.pythonPath,
-        pipPath: pythonVersion.pipPath,
+      await runUvSync({
         uvPath,
-        filePath: exportedReq,
-        workPath,
-        targetDir: vendorBaseDir,
-        meta
+        venvPath,
+        projectDir,
+        locked: true
       });
-      installedFromProjectFiles = true;
     }
   }
-  if (!installedFromProjectFiles && fsFiles[requirementsTxt]) {
-    (0, import_build_utils5.debug)('Found local "requirements.txt"');
-    const requirementsTxtPath = fsFiles[requirementsTxt].fsPath;
-    await installRequirementsFile({
-      pythonPath: pythonVersion.pythonPath,
-      pipPath: pythonVersion.pipPath,
-      uvPath,
-      filePath: requirementsTxtPath,
-      workPath,
-      targetDir: vendorBaseDir,
-      meta
-    });
-  } else if (!installedFromProjectFiles && fsFiles["requirements.txt"]) {
-    (0, import_build_utils5.debug)('Found global "requirements.txt"');
-    const requirementsTxtPath = fsFiles["requirements.txt"].fsPath;
-    await installRequirementsFile({
-      pythonPath: pythonVersion.pythonPath,
-      pipPath: pythonVersion.pipPath,
-      uvPath,
-      filePath: requirementsTxtPath,
-      workPath,
-      targetDir: vendorBaseDir,
-      meta
-    });
-  }
   const originalPyPath = (0, import_path5.join)(__dirname, "..", "vc_init.py");
   const originalHandlerPyContents = await readFile(originalPyPath, "utf8");
-  (0, import_build_utils5.debug)("Entrypoint is", entrypoint);
+  (0, import_build_utils7.debug)("Entrypoint is", entrypoint);
   const moduleName = entrypoint.replace(/\//g, ".").replace(/\.py$/i, "");
   const vendorDir = resolveVendorDir();
   const suffix = meta.isDev && !entrypoint.endsWith(".py") ? ".py" : "";
   const entrypointWithSuffix = `${entrypoint}${suffix}`;
-  (0, import_build_utils5.debug)("Entrypoint with suffix is", entrypointWithSuffix);
+  (0, import_build_utils7.debug)("Entrypoint with suffix is", entrypointWithSuffix);
   const handlerPyContents = originalHandlerPyContents.replace(/__VC_HANDLER_MODULE_NAME/g, moduleName).replace(/__VC_HANDLER_ENTRYPOINT/g, entrypointWithSuffix).replace(/__VC_HANDLER_VENDOR_DIR/g, vendorDir);
   const predefinedExcludes = [
     ".git/**",
@@ -4000,7 +4489,12 @@ var build = async ({
     "**/.venv/**",
     "**/venv/**",
     "**/__pycache__/**",
-    "**/public/**"
+    "**/.mypy_cache/**",
+    "**/.ruff_cache/**",
+    "**/public/**",
+    "**/pnpm-lock.yaml",
+    "**/yarn.lock",
+    "**/package-lock.json"
   ];
   const lambdaEnv = {};
   lambdaEnv.PYTHONPATH = vendorDir;
@@ -4008,26 +4502,21 @@ var build = async ({
     cwd: workPath,
     ignore: config && typeof config.excludeFiles === "string" ? [...predefinedExcludes, config.excludeFiles] : predefinedExcludes
   };
-  const files = await (0, import_build_utils5.glob)("**", globOptions);
-  try {
-    const cachedVendorAbs = (0, import_path5.join)(vendorBaseDir, resolveVendorDir());
-    if (import_fs5.default.existsSync(cachedVendorAbs)) {
-      const vendorFiles = await (0, import_build_utils5.glob)("**", cachedVendorAbs, resolveVendorDir());
-      for (const [p, f] of Object.entries(vendorFiles)) {
-        files[p] = f;
-      }
-    }
-  } catch (err) {
-    console.log("Failed to include cached vendor directory");
-    throw err;
+  const files = await (0, import_build_utils7.glob)("**", globOptions);
+  const vendorFiles = await mirrorSitePackagesIntoVendor({
+    venvPath,
+    vendorDirName: vendorDir
+  });
+  for (const [p, f] of Object.entries(vendorFiles)) {
+    files[p] = f;
   }
   const handlerPyFilename = "vc__handler__python";
-  files[`${handlerPyFilename}.py`] = new import_build_utils5.FileBlob({ data: handlerPyContents });
+  files[`${handlerPyFilename}.py`] = new import_build_utils7.FileBlob({ data: handlerPyContents });
   if (config.framework === "fasthtml") {
     const { SESSKEY = "" } = process.env;
-    files[".sesskey"] = new import_build_utils5.FileBlob({ data: `"${SESSKEY}"` });
+    files[".sesskey"] = new import_build_utils7.FileBlob({ data: `"${SESSKEY}"` });
   }
-  const output = new import_build_utils5.Lambda({
+  const output = new import_build_utils7.Lambda({
     files,
     handler: `${handlerPyFilename}.vc_handler`,
     runtime: pythonVersion.runtime,