@vercel/python 5.0.5 → 5.0.7

package/dist/index.js

@@ -48,7 +48,7 @@ var require_windows = __commonJS({
   "../../node_modules/.pnpm/isexe@2.0.0/node_modules/isexe/windows.js"(exports, module2) {
     module2.exports = isexe;
     isexe.sync = sync;
-    var fs3 = require("fs");
+    var fs5 = require("fs");
     function checkPathExt(path, options) {
       var pathext = options.pathExt !== void 0 ? options.pathExt : process.env.PATHEXT;
       if (!pathext) {
@@ -73,12 +73,12 @@ var require_windows = __commonJS({
       return checkPathExt(path, options);
     }
     function isexe(path, options, cb) {
-      fs3.stat(path, function(er, stat) {
+      fs5.stat(path, function(er, stat) {
         cb(er, er ? false : checkStat(stat, path, options));
       });
     }
     function sync(path, options) {
-      return checkStat(fs3.statSync(path), path, options);
+      return checkStat(fs5.statSync(path), path, options);
     }
   }
 });
@@ -88,14 +88,14 @@ var require_mode = __commonJS({
   "../../node_modules/.pnpm/isexe@2.0.0/node_modules/isexe/mode.js"(exports, module2) {
     module2.exports = isexe;
     isexe.sync = sync;
-    var fs3 = require("fs");
+    var fs5 = require("fs");
     function isexe(path, options, cb) {
-      fs3.stat(path, function(er, stat) {
+      fs5.stat(path, function(er, stat) {
         cb(er, er ? false : checkStat(stat, options));
       });
     }
     function sync(path, options) {
-      return checkStat(fs3.statSync(path), options);
+      return checkStat(fs5.statSync(path), options);
     }
     function checkStat(stat, options) {
       return stat.isFile() && checkMode(stat, options);
@@ -119,7 +119,7 @@ var require_mode = __commonJS({
 // ../../node_modules/.pnpm/isexe@2.0.0/node_modules/isexe/index.js
 var require_isexe = __commonJS({
   "../../node_modules/.pnpm/isexe@2.0.0/node_modules/isexe/index.js"(exports, module2) {
-    var fs3 = require("fs");
+    var fs5 = require("fs");
     var core;
     if (process.platform === "win32" || global.TESTING_WINDOWS) {
       core = require_windows();
@@ -395,7 +395,7 @@ var require_shebang_command = __commonJS({
 var require_readShebang = __commonJS({
   "../../node_modules/.pnpm/cross-spawn@6.0.5/node_modules/cross-spawn/lib/util/readShebang.js"(exports, module2) {
     "use strict";
-    var fs3 = require("fs");
+    var fs5 = require("fs");
     var shebangCommand = require_shebang_command();
     function readShebang(command) {
       const size = 150;
@@ -408,9 +408,9 @@ var require_readShebang = __commonJS({
       }
       let fd;
       try {
-        fd = fs3.openSync(command, "r");
-        fs3.readSync(fd, buffer, 0, size, 0);
-        fs3.closeSync(fd);
+        fd = fs5.openSync(command, "r");
+        fs5.readSync(fd, buffer, 0, size, 0);
+        fs5.closeSync(fd);
       } catch (e) {
       }
       return shebangCommand(buffer.toString());
@@ -423,15 +423,15 @@ var require_readShebang = __commonJS({
 var require_semver = __commonJS({
   "../../node_modules/.pnpm/semver@5.7.2/node_modules/semver/semver.js"(exports, module2) {
     exports = module2.exports = SemVer;
-    var debug3;
+    var debug5;
     if (typeof process === "object" && process.env && process.env.NODE_DEBUG && /\bsemver\b/i.test(process.env.NODE_DEBUG)) {
-      debug3 = function() {
+      debug5 = function() {
         var args = Array.prototype.slice.call(arguments, 0);
         args.unshift("SEMVER");
         console.log.apply(console, args);
       };
     } else {
-      debug3 = function() {
+      debug5 = function() {
       };
     }
     exports.SEMVER_SPEC_VERSION = "2.0.0";
@@ -540,15 +540,15 @@ var require_semver = __commonJS({
     var STAR = R++;
     src[STAR] = "(<|>)?=?\\s*\\*";
     for (i = 0; i < R; i++) {
-      debug3(i, src[i]);
+      debug5(i, src[i]);
       if (!re[i]) {
         re[i] = new RegExp(src[i]);
         safeRe[i] = new RegExp(makeSafeRe(src[i]));
       }
     }
     var i;
-    exports.parse = parse;
-    function parse(version2, options) {
+    exports.parse = parse2;
+    function parse2(version2, options) {
       if (!options || typeof options !== "object") {
         options = {
           loose: !!options,
@@ -576,12 +576,12 @@ var require_semver = __commonJS({
     }
     exports.valid = valid;
     function valid(version2, options) {
-      var v = parse(version2, options);
+      var v = parse2(version2, options);
       return v ? v.version : null;
     }
     exports.clean = clean;
     function clean(version2, options) {
-      var s = parse(version2.trim().replace(/^[=v]+/, ""), options);
+      var s = parse2(version2.trim().replace(/^[=v]+/, ""), options);
       return s ? s.version : null;
     }
     exports.SemVer = SemVer;
@@ -607,7 +607,7 @@ var require_semver = __commonJS({
       if (!(this instanceof SemVer)) {
         return new SemVer(version2, options);
       }
-      debug3("SemVer", version2, options);
+      debug5("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) {
-      debug3("SemVer.compare", this.version, this.options, other);
+      debug5("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];
-        debug3("prerelease compare", i2, a, b);
+        debug5("prerelease compare", i2, a, b);
         if (a === void 0 && b === void 0) {
           return 0;
         } else if (b === void 0) {
@@ -791,8 +791,8 @@ var require_semver = __commonJS({
       if (eq(version1, version2)) {
         return null;
       } else {
-        var v1 = parse(version1);
-        var v2 = parse(version2);
+        var v1 = parse2(version1);
+        var v2 = parse2(version2);
         var prefix = "";
         if (v1.prerelease.length || v2.prerelease.length) {
           prefix = "pre";
@@ -935,7 +935,7 @@ var require_semver = __commonJS({
         return new Comparator(comp, options);
       }
       comp = comp.trim().split(/\s+/).join(" ");
-      debug3("comparator", comp, options);
+      debug5("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;
       }
-      debug3("comp", this);
+      debug5("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) {
-      debug3("Comparator.test", version2, this.options.loose);
+      debug5("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);
-      debug3("hyphen replace", range);
+      debug5("hyphen replace", range);
       range = range.replace(safeRe[COMPARATORTRIM], comparatorTrimReplace);
-      debug3("comparator trim", range, safeRe[COMPARATORTRIM]);
+      debug5("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) {
-      debug3("comp", comp, options);
+      debug5("comp", comp, options);
       comp = replaceCarets(comp, options);
-      debug3("caret", comp);
+      debug5("caret", comp);
       comp = replaceTildes(comp, options);
-      debug3("tildes", comp);
+      debug5("tildes", comp);
       comp = replaceXRanges(comp, options);
-      debug3("xrange", comp);
+      debug5("xrange", comp);
       comp = replaceStars(comp, options);
-      debug3("stars", comp);
+      debug5("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) {
-        debug3("tilde", comp, _, M, m, p, pr);
+        debug5("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) {
-          debug3("replaceTilde pr", pr);
+          debug5("replaceTilde pr", pr);
           ret = ">=" + M + "." + m + "." + p + "-" + pr + " <" + M + "." + (+m + 1) + ".0";
         } else {
           ret = ">=" + M + "." + m + "." + p + " <" + M + "." + (+m + 1) + ".0";
         }
-        debug3("tilde return", ret);
+        debug5("tilde return", ret);
         return ret;
       });
     }
@@ -1138,10 +1138,10 @@ var require_semver = __commonJS({
       }).join(" ");
     }
     function replaceCaret(comp, options) {
-      debug3("caret", comp, options);
+      debug5("caret", comp, options);
       var r = options.loose ? safeRe[CARETLOOSE] : safeRe[CARET];
       return comp.replace(r, function(_, M, m, p, pr) {
-        debug3("caret", comp, _, M, m, p, pr);
+        debug5("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) {
-          debug3("replaceCaret pr", pr);
+          debug5("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 {
-          debug3("no pr");
+          debug5("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";
           }
         }
-        debug3("caret return", ret);
+        debug5("caret return", ret);
         return ret;
       });
     }
     function replaceXRanges(comp, options) {
-      debug3("replaceXRanges", comp, options);
+      debug5("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) {
-        debug3("xRange", comp, ret, gtlt, M, m, p, pr);
+        debug5("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";
         }
-        debug3("xRange return", ret);
+        debug5("xRange return", ret);
         return ret;
       });
     }
     function replaceStars(comp, options) {
-      debug3("replaceStars", comp, options);
+      debug5("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++) {
-          debug3(set[i2].semver);
+          debug5(set[i2].semver);
           if (set[i2].semver === ANY) {
             continue;
           }
@@ -1462,7 +1462,7 @@ var require_semver = __commonJS({
     }
     exports.prerelease = prerelease;
     function prerelease(version2, options) {
-      var parsed = parse(version2, options);
+      var parsed = parse2(version2, options);
       return parsed && parsed.prerelease.length ? parsed.prerelease : null;
     }
     exports.intersects = intersects;
@@ -1483,7 +1483,7 @@ var require_semver = __commonJS({
       if (match == null) {
         return null;
       }
-      return parse(match[1] + "." + (match[2] || "0") + "." + (match[3] || "0"));
+      return parse2(match[1] + "." + (match[2] || "0") + "." + (match[3] || "0"));
     }
   }
 });
@@ -1551,7 +1551,7 @@ var require_parse = __commonJS({
       }
       return parsed;
     }
-    function parse(command, args, options) {
+    function parse2(command, args, options) {
       if (args && !Array.isArray(args)) {
         options = args;
         args = null;
@@ -1570,7 +1570,7 @@ var require_parse = __commonJS({
       };
       return options.shell ? parseShell(parsed) : parseNonShell(parsed);
     }
-    module2.exports = parse;
+    module2.exports = parse2;
   }
 });
 
@@ -1629,24 +1629,24 @@ var require_cross_spawn = __commonJS({
   "../../node_modules/.pnpm/cross-spawn@6.0.5/node_modules/cross-spawn/index.js"(exports, module2) {
     "use strict";
     var cp = require("child_process");
-    var parse = require_parse();
+    var parse2 = require_parse();
     var enoent = require_enoent();
-    function spawn(command, args, options) {
-      const parsed = parse(command, args, options);
+    function spawn3(command, args, options) {
+      const parsed = parse2(command, args, options);
       const spawned = cp.spawn(parsed.command, parsed.args, parsed.options);
       enoent.hookChildProcess(spawned, parsed);
       return spawned;
     }
     function spawnSync(command, args, options) {
-      const parsed = parse(command, args, options);
+      const parsed = parse2(command, args, options);
       const result = cp.spawnSync(parsed.command, parsed.args, parsed.options);
       result.error = result.error || enoent.verifyENOENTSync(result.status, parsed);
       return result;
     }
-    module2.exports = spawn;
-    module2.exports.spawn = spawn;
+    module2.exports = spawn3;
+    module2.exports.spawn = spawn3;
     module2.exports.sync = spawnSync;
-    module2.exports._parse = parse;
+    module2.exports._parse = parse2;
     module2.exports._enoent = enoent;
   }
 });
@@ -1895,9 +1895,9 @@ var require_pump = __commonJS({
   "../../node_modules/.pnpm/pump@3.0.2/node_modules/pump/index.js"(exports, module2) {
     var once = require_once();
     var eos = require_end_of_stream();
-    var fs3;
+    var fs5;
     try {
-      fs3 = require("fs");
+      fs5 = require("fs");
     } catch (e) {
     }
     var noop = function() {
@@ -1909,9 +1909,9 @@ var require_pump = __commonJS({
     var isFS = function(stream) {
       if (!ancient)
         return false;
-      if (!fs3)
+      if (!fs5)
         return false;
-      return (stream instanceof (fs3.ReadStream || noop) || stream instanceof (fs3.WriteStream || noop)) && isFn(stream.close);
+      return (stream instanceof (fs5.ReadStream || noop) || stream instanceof (fs5.WriteStream || noop)) && isFn(stream.close);
     };
     var isRequest = function(stream) {
       return stream.setHeader && isFn(stream.abort);
@@ -2651,7 +2651,7 @@ ${stderr}${stdout}`;
 var require_lib = __commonJS({
   "../../node_modules/.pnpm/which@3.0.0/node_modules/which/lib/index.js"(exports, module2) {
     var isexe = require_isexe();
-    var { join: join3, delimiter, sep, posix } = require("path");
+    var { join: join5, 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 + join3(pathPart, cmd);
+      return prefix + join5(pathPart, cmd);
     };
     var which3 = async (cmd, opt = {}) => {
       const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
@@ -2739,18 +2739,19 @@ var require_lib = __commonJS({
 var src_exports = {};
 __export(src_exports, {
   build: () => build,
+  defaultShouldServe: () => defaultShouldServe,
   downloadFilesInWorkPath: () => downloadFilesInWorkPath,
   installRequirement: () => installRequirement,
   installRequirementsFile: () => installRequirementsFile,
-  shouldServe: () => import_build_utils3.shouldServe,
+  shouldServe: () => shouldServe,
+  startDevServer: () => startDevServer,
   version: () => version
 });
 module.exports = __toCommonJS(src_exports);
-var import_fs2 = __toESM(require("fs"));
-var import_execa2 = __toESM(require_execa());
+var import_fs5 = __toESM(require("fs"));
 var import_util = require("util");
-var import_path2 = require("path");
-var import_build_utils3 = require("@vercel/build-utils");
+var import_path5 = require("path");
+var import_build_utils5 = require("@vercel/build-utils");
 
 // src/install.ts
 var import_execa = __toESM(require_execa());
@@ -2835,16 +2836,10 @@ async function getUserScriptsDir(pythonPath) {
     return null;
   }
 }
-async function pipInstall(pipPath, pythonPath, workPath, args) {
-  const target = resolveVendorDir();
+async function pipInstall(pipPath, uvPath, workPath, args, targetDir) {
+  const target = targetDir ? (0, import_path.join)(targetDir, resolveVendorDir()) : resolveVendorDir();
   process.env.PIP_USER = "0";
-  let uvBin = null;
-  try {
-    uvBin = await getUvBinaryOrInstall(pythonPath);
-  } catch (err) {
-    console.log("Failed to install uv, falling back to pip");
-  }
-  if (uvBin) {
+  if (uvPath) {
     const uvArgs = [
       "pip",
       "install",
@@ -2854,15 +2849,16 @@ async function pipInstall(pipPath, pythonPath, workPath, args) {
       target,
       ...args
     ];
-    const prettyUv = `${uvBin} ${uvArgs.join(" ")}`;
+    const prettyUv = `${uvPath} ${uvArgs.join(" ")}`;
     (0, import_build_utils.debug)(`Running "${prettyUv}"...`);
     try {
-      await (0, import_execa.default)(uvBin, uvArgs, {
+      await (0, import_execa.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}`);
     }
   }
   const cmdArgs = [
@@ -2882,11 +2878,12 @@ async function pipInstall(pipPath, pythonPath, workPath, args) {
     });
   } catch (err) {
     console.log(`Failed to run "${pretty}"`);
+    (0, import_build_utils.debug)(`error: ${err}`);
     throw err;
   }
 }
 async function maybeFindUvBin(pythonPath) {
-  const found = import_which.default.sync(uvExec, { nothrow: true });
+  const found = import_which.default.sync("uv", { nothrow: true });
   if (found)
     return found;
   try {
@@ -2897,10 +2894,7 @@ async function maybeFindUvBin(pythonPath) {
         return uvPath;
     }
   } catch (err) {
-    (0, import_build_utils.debug)(
-      "Failed to resolve uv from interpreter's global scripts directory",
-      err
-    );
+    (0, import_build_utils.debug)("Failed to resolve Python global scripts directory", err);
   }
   try {
     const userScriptsDir = await getUserScriptsDir(pythonPath);
@@ -2910,10 +2904,7 @@ async function maybeFindUvBin(pythonPath) {
         return uvPath;
     }
   } catch (err) {
-    (0, import_build_utils.debug)(
-      "Failed to resolve uv from interpreter's user scripts directory",
-      err
-    );
+    (0, import_build_utils.debug)("Failed to resolve Python user scripts directory", err);
   }
   try {
     const candidates = [];
@@ -2935,10 +2926,8 @@ async function maybeFindUvBin(pythonPath) {
 }
 async function getUvBinaryOrInstall(pythonPath) {
   const uvBin = await maybeFindUvBin(pythonPath);
-  if (uvBin) {
-    console.log(`Using uv at "${uvBin}"`);
+  if (uvBin)
     return uvBin;
-  }
   try {
     console.log("Installing uv...");
     await (0, import_execa.default)(
@@ -2969,41 +2958,116 @@ async function getUvBinaryOrInstall(pythonPath) {
 async function installRequirement({
   pythonPath,
   pipPath,
+  uvPath,
   dependency,
   version: version2,
   workPath,
+  targetDir,
   meta,
   args = []
 }) {
-  if (meta.isDev && await isInstalled(pythonPath, dependency, workPath)) {
+  const actualTargetDir = targetDir || workPath;
+  if (meta.isDev && await isInstalled(pythonPath, dependency, actualTargetDir)) {
     (0, import_build_utils.debug)(
-      `Skipping ${dependency} dependency installation, already installed in ${workPath}`
+      `Skipping ${dependency} dependency installation, already installed in ${actualTargetDir}`
     );
     return;
   }
   const exact = `${dependency}==${version2}`;
-  await pipInstall(pipPath, pythonPath, workPath, [exact, ...args]);
+  await pipInstall(pipPath, uvPath, workPath, [exact, ...args], targetDir);
 }
 async function installRequirementsFile({
   pythonPath,
   pipPath,
+  uvPath,
   filePath,
   workPath,
+  targetDir,
   meta,
   args = []
 }) {
-  if (meta.isDev && await areRequirementsInstalled(pythonPath, filePath, workPath)) {
+  const actualTargetDir = targetDir || workPath;
+  if (meta.isDev && await areRequirementsInstalled(pythonPath, filePath, actualTargetDir)) {
     (0, import_build_utils.debug)(`Skipping requirements file installation, already installed`);
     return;
   }
-  await pipInstall(pipPath, pythonPath, workPath, [
-    "--upgrade",
-    "-r",
-    filePath,
-    ...args
-  ]);
+  await pipInstall(
+    pipPath,
+    uvPath,
+    workPath,
+    ["--upgrade", "-r", filePath, ...args],
+    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;
+}
+async function exportRequirementsFromPipfile({
+  pythonPath,
+  pipPath,
+  uvPath,
+  projectDir,
+  meta
+}) {
+  const tempDir = await import_fs.default.promises.mkdtemp(
+    (0, import_path.join)(import_os.default.tmpdir(), "vercel-pipenv-")
+  );
+  await installRequirement({
+    pythonPath,
+    pipPath,
+    dependency: "pipfile-requirements",
+    version: "0.3.0",
+    workPath: tempDir,
+    meta,
+    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}...`);
+  let stdout;
+  try {
+    const { stdout: out } = await (0, import_execa.default)(convertCmd, [], {
+      cwd: projectDir,
+      env: { ...process.env, PYTHONPATH: tempVendorDir }
+    });
+    stdout = out;
+  } catch (err) {
+    throw new Error(
+      `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}`);
+  return outPath;
 }
 
+// src/index.ts
+var import_build_utils6 = require("@vercel/build-utils");
+
 // src/version.ts
 var import_build_utils2 = require("@vercel/build-utils");
 var import_which2 = __toESM(require_lib());
@@ -3066,35 +3130,59 @@ function getLatestPythonVersion({
 }
 function getSupportedPythonVersion({
   isDev,
-  pipLockPythonVersion
+  declaredPythonVersion
 }) {
   if (isDev) {
     return getDevPythonVersion();
   }
   let selection = getLatestPythonVersion({ isDev: false });
-  if (typeof pipLockPythonVersion === "string") {
-    const found = allOptions.find(
-      (o) => o.version === pipLockPythonVersion && isInstalled2(o)
-    );
-    if (found) {
-      selection = found;
+  if (declaredPythonVersion) {
+    const { version: version2, source } = declaredPythonVersion;
+    const requested = allOptions.find((o) => o.version === version2);
+    if (requested) {
+      if (isDiscontinued(requested)) {
+        throw new import_build_utils2.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.`
+        });
+      }
+      if (isInstalled2(requested)) {
+        selection = requested;
+        console.log(`Using Python ${selection.version} from ${source}`);
+      } else {
+        console.warn(
+          `Warning: Python version "${version2}" detected in ${source} is not installed and will be ignored. http://vercel.link/python-version`
+        );
+        console.log(
+          `Falling back to latest installed version: ${selection.version}`
+        );
+      }
     } else {
       console.warn(
-        `Warning: Python version "${pipLockPythonVersion}" detected in Pipfile.lock is invalid and will be ignored. http://vercel.link/python-version`
+        `Warning: Python version "${version2}" detected in ${source} is invalid and will be ignored. http://vercel.link/python-version`
+      );
+      console.log(
+        `Falling back to latest installed version: ${selection.version}`
       );
     }
+  } else {
+    console.log(
+      `No Python version specified in pyproject.toml or Pipfile.lock. Using latest installed version: ${selection.version}`
+    );
   }
   if (isDiscontinued(selection)) {
     throw new import_build_utils2.NowBuildError({
       code: "BUILD_UTILS_PYTHON_VERSION_DISCONTINUED",
       link: "http://vercel.link/python-version",
-      message: `Python version "${selection.version}" detected in Pipfile.lock is discontinued and must be upgraded.`
+      message: `Python version "${selection.version}" declared in project configuration is discontinued and must be upgraded.`
     });
   }
   if (selection.discontinueDate) {
     const d = selection.discontinueDate.toISOString().split("T")[0];
+    const srcSuffix = declaredPythonVersion ? `detected in ${declaredPythonVersion.source}` : "selected by runtime";
     console.warn(
-      `Error: Python version "${selection.version}" detected in Pipfile.lock has reached End-of-Life. Deployments created on or after ${d} will fail to build. http://vercel.link/python-version`
+      `Error: Python version "${selection.version}" ${srcSuffix} has reached End-of-Life. Deployments created on or after ${d} will fail to build. http://vercel.link/python-version`
     );
   }
   return selection;
@@ -3107,14 +3195,23 @@ function isInstalled2({ pipPath, pythonPath }) {
   return Boolean(import_which2.default.sync(pipPath, { nothrow: true })) && Boolean(import_which2.default.sync(pythonPath, { nothrow: true }));
 }
 
-// src/index.ts
-var readFile = (0, import_util.promisify)(import_fs2.default.readFile);
-var writeFile = (0, import_util.promisify)(import_fs2.default.writeFile);
-var fastapiEntrypointFilenames = ["app", "index", "server", "main"];
-var fastapiEntrypointDirs = ["", "src", "app"];
-var fastapiContentRegex = /(from\s+fastapi\s+import\s+FastAPI|import\s+fastapi|FastAPI\s*\()/;
-var fastapiCandidateEntrypoints = fastapiEntrypointFilenames.flatMap(
-  (filename) => fastapiEntrypointDirs.map((dir) => import_path2.posix.join(dir, `${filename}.py`))
+// src/start-dev-server.ts
+var import_child_process2 = require("child_process");
+var import_fs4 = require("fs");
+var import_path4 = require("path");
+var import_build_utils4 = 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 FASTAPI_ENTRYPOINT_FILENAMES = ["app", "index", "server", "main"];
+var FASTAPI_ENTRYPOINT_DIRS = ["", "src", "app"];
+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`)
+  )
 );
 function isFastapiEntrypoint(file) {
   try {
@@ -3122,39 +3219,391 @@ function isFastapiEntrypoint(file) {
     if (!fsPath)
       return false;
     const contents = import_fs2.default.readFileSync(fsPath, "utf8");
-    return fastapiContentRegex.test(contents);
+    return FASTAPI_CONTENT_REGEX.test(contents);
   } catch {
     return false;
   }
 }
-async function pipenvConvert(cmd, srcDir, env) {
-  (0, import_build_utils3.debug)("Running pipfile2req...");
+async function detectFastapiEntrypoint(workPath, configuredEntrypoint) {
+  const entry = configuredEntrypoint.endsWith(".py") ? configuredEntrypoint : `${configuredEntrypoint}.py`;
   try {
-    const out = await import_execa2.default.stdout(cmd, [], {
-      cwd: srcDir,
-      env
+    const fsFiles = await (0, import_build_utils3.glob)("**", workPath);
+    if (fsFiles[entry])
+      return entry;
+    const candidates = FASTAPI_CANDIDATE_ENTRYPOINTS.filter(
+      (c) => !!fsFiles[c]
+    );
+    if (candidates.length > 0) {
+      const fastapiEntrypoint = candidates.find(
+        (c) => isFastapiEntrypoint(fsFiles[c])
+      ) || candidates[0];
+      (0, import_build_utils3.debug)(`Detected FastAPI entrypoint: ${fastapiEntrypoint}`);
+      return fastapiEntrypoint;
+    }
+    return null;
+  } catch {
+    (0, import_build_utils3.debug)("Failed to discover entrypoint for FastAPI");
+    return null;
+  }
+}
+
+// src/utils.ts
+var import_child_process = require("child_process");
+var import_fs3 = __toESM(require("fs"));
+var import_path3 = require("path");
+var tryImport = (pythonPath, mod) => new Promise((res) => {
+  const check = (0, import_child_process.spawn)(pythonPath, ["-c", `import ${mod}`], {
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+  check.once("error", () => res(false));
+  check.once("exit", (code) => res(code === 0));
+});
+var detectAsgiServer = async (workPath, pythonPath) => new Promise((resolve, reject) => {
+  tryImport(pythonPath, "uvicorn").then((hasUvicorn) => {
+    if (hasUvicorn)
+      return resolve("uvicorn");
+    tryImport(pythonPath, "hypercorn").then((hasHypercorn) => {
+      if (hasHypercorn)
+        return resolve("hypercorn");
+      const { venvRoot } = useVirtualEnv(workPath, {}, pythonPath);
+      const baseErrorMessage = 'No ASGI server found. Please install either "uvicorn" or "hypercorn" (e.g. "pip install uvicorn").';
+      const errorMessage = !venvRoot ? `${baseErrorMessage} If you are using a virtual environment, please activate it and try again.` : baseErrorMessage;
+      reject(new Error(errorMessage));
     });
-    (0, import_build_utils3.debug)("Contents of requirements.txt is: " + out);
-    import_fs2.default.writeFileSync((0, import_path2.join)(srcDir, "requirements.txt"), out);
+  });
+});
+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 };
+    }
+  }
+  return { pythonCmd };
+}
+
+// src/start-dev-server.ts
+function silenceNodeWarnings() {
+  const original = process.emitWarning.bind(
+    process
+  );
+  let active = true;
+  const wrapped = (warning, ...args) => {
+    if (!active) {
+      return original(
+        warning,
+        ...args
+      );
+    }
+    return;
+  };
+  process.emitWarning = wrapped;
+  return () => {
+    if (!active)
+      return;
+    active = false;
+    if (process.emitWarning === wrapped) {
+      process.emitWarning = original;
+    }
+  };
+}
+var ANSI_PATTERN = "[\\u001B\\u009B][[\\]()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nq-uy=><]";
+var ANSI_ESCAPE_RE = new RegExp(ANSI_PATTERN, "g");
+var stripAnsi = (s) => s.replace(ANSI_ESCAPE_RE, "");
+var ASGI_SHIM_MODULE = "vc_init_dev_asgi";
+var PERSISTENT_SERVERS = /* @__PURE__ */ new Map();
+var PENDING_STARTS = /* @__PURE__ */ new Map();
+var restoreWarnings = null;
+var cleanupHandlersInstalled = false;
+function installGlobalCleanupHandlers() {
+  if (cleanupHandlersInstalled)
+    return;
+  cleanupHandlersInstalled = true;
+  const killAll = () => {
+    for (const [key, info] of PERSISTENT_SERVERS.entries()) {
+      try {
+        process.kill(info.pid, "SIGTERM");
+      } catch (err) {
+        (0, import_build_utils4.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}`);
+      }
+      PERSISTENT_SERVERS.delete(key);
+    }
+    if (restoreWarnings) {
+      try {
+        restoreWarnings();
+      } catch (err) {
+        (0, import_build_utils4.debug)(`Error restoring warnings: ${err}`);
+      }
+      restoreWarnings = null;
+    }
+  };
+  process.on("SIGINT", () => {
+    killAll();
+    process.exit(130);
+  });
+  process.on("SIGTERM", () => {
+    killAll();
+    process.exit(143);
+  });
+  process.on("exit", () => {
+    killAll();
+  });
+}
+function createDevStaticShim(workPath, modulePath) {
+  try {
+    const vercelPythonDir = (0, import_path4.join)(workPath, ".vercel", "python");
+    (0, import_fs4.mkdirSync)(vercelPythonDir, { recursive: true });
+    const shimPath = (0, import_path4.join)(vercelPythonDir, `${ASGI_SHIM_MODULE}.py`);
+    const templatePath = (0, import_path4.join)(__dirname, "..", `${ASGI_SHIM_MODULE}.py`);
+    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}`);
+    return ASGI_SHIM_MODULE;
   } catch (err) {
-    console.log('Failed to run "pipfile2req"');
-    throw err;
+    (0, import_build_utils4.debug)(`Failed to prepare dev static shim: ${err?.message || err}`);
+    return null;
   }
 }
+var startDevServer = async (opts) => {
+  const { entrypoint: rawEntrypoint, workPath, meta = {}, config } = opts;
+  if (config?.framework !== "fastapi") {
+    return null;
+  }
+  if (!restoreWarnings)
+    restoreWarnings = silenceNodeWarnings();
+  installGlobalCleanupHandlers();
+  const detected = await detectFastapiEntrypoint(workPath, rawEntrypoint);
+  if (!detected) {
+    throw new Error(
+      `No FastAPI entrypoint found. Searched for: ${FASTAPI_CANDIDATE_ENTRYPOINTS.join(", ")}`
+    );
+  }
+  const entry = detected;
+  const modulePath = entry.replace(/\.py$/i, "").replace(/[\\/]/g, ".");
+  const env = { ...process.env, ...meta.env || {} };
+  const serverKey = `${workPath}::${entry}`;
+  const existing = PERSISTENT_SERVERS.get(serverKey);
+  if (existing) {
+    return {
+      port: existing.port,
+      pid: existing.pid,
+      shutdown: async () => {
+      }
+    };
+  }
+  {
+    const pending = PENDING_STARTS.get(serverKey);
+    if (pending) {
+      const { port, pid } = await pending;
+      return {
+        port,
+        pid,
+        shutdown: async () => {
+        }
+      };
+    }
+  }
+  let childProcess = null;
+  let stdoutLogListener = null;
+  let stderrLogListener = null;
+  let resolveChildReady;
+  let rejectChildReady;
+  const childReady = new Promise(
+    (resolve, reject) => {
+      resolveChildReady = resolve;
+      rejectChildReady = reject;
+    }
+  );
+  PENDING_STARTS.set(serverKey, childReady);
+  try {
+    await new Promise((resolve, 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}`);
+      } else {
+        const { pythonCmd: venvPythonCmd, venvRoot } = useVirtualEnv(
+          workPath,
+          env,
+          systemPython
+        );
+        pythonCmd = venvPythonCmd;
+        if (venvRoot) {
+          (0, import_build_utils4.debug)(`Using virtualenv at ${venvRoot}`);
+        } else {
+          (0, import_build_utils4.debug)("No virtualenv found");
+        }
+      }
+      const devShimModule = createDevStaticShim(workPath, modulePath);
+      if (devShimModule) {
+        const vercelPythonDir = (0, import_path4.join)(workPath, ".vercel", "python");
+        const existingPythonPath = env.PYTHONPATH || "";
+        env.PYTHONPATH = existingPythonPath ? `${vercelPythonDir}:${existingPythonPath}` : vercelPythonDir;
+      }
+      detectAsgiServer(workPath, pythonCmd).then(async (serverKind) => {
+        if (resolved)
+          return;
+        const host = "127.0.0.1";
+        const argv = serverKind === "uvicorn" ? [
+          "-u",
+          "-m",
+          "uvicorn",
+          `${devShimModule || modulePath}:app`,
+          "--host",
+          host,
+          "--port",
+          "0",
+          "--use-colors"
+        ] : [
+          "-u",
+          "-m",
+          "hypercorn",
+          `${devShimModule || modulePath}:app`,
+          "-b",
+          `${host}:0`
+        ];
+        (0, import_build_utils4.debug)(
+          `Starting dev server (${serverKind}): ${pythonCmd} ${argv.join(" ")}`
+        );
+        const child = (0, import_child_process2.spawn)(pythonCmd, argv, {
+          cwd: workPath,
+          env,
+          stdio: ["inherit", "pipe", "pipe"]
+        });
+        childProcess = child;
+        stdoutLogListener = (buf) => {
+          const s = buf.toString();
+          for (const line of s.split(/\r?\n/)) {
+            if (line) {
+              process.stdout.write(line.endsWith("\n") ? line : line + "\n");
+            }
+          }
+        };
+        stderrLogListener = (buf) => {
+          const s = buf.toString();
+          for (const line of s.split(/\r?\n/)) {
+            if (line) {
+              process.stderr.write(line.endsWith("\n") ? line : line + "\n");
+            }
+          }
+        };
+        child.stdout?.on("data", stdoutLogListener);
+        child.stderr?.on("data", stderrLogListener);
+        const readinessRegexes = [
+          /Uvicorn running on https?:\/\/(?:\[[^\]]+\]|[^:]+):(\d+)/i,
+          /Hypercorn running on https?:\/\/(?:\[[^\]]+\]|[^:]+):(\d+)/i,
+          /(?:Running|Serving) on https?:\/\/(?:\[[^\]]+\]|[^:\s]+):(\d+)/i
+        ];
+        const onDetect = (chunk) => {
+          const text = chunk.toString();
+          const clean = stripAnsi(text);
+          let portMatch = null;
+          for (const rx of readinessRegexes) {
+            const m = clean.match(rx);
+            if (m) {
+              portMatch = m;
+              break;
+            }
+          }
+          if (portMatch && child.pid) {
+            if (!resolved) {
+              resolved = true;
+              child.stdout?.removeListener("data", onDetect);
+              child.stderr?.removeListener("data", onDetect);
+              const port2 = Number(portMatch[1]);
+              resolveChildReady({ port: port2, pid: child.pid });
+              resolve();
+            }
+          }
+        };
+        child.stdout?.on("data", onDetect);
+        child.stderr?.on("data", onDetect);
+        child.once("error", (err) => {
+          if (!resolved) {
+            rejectChildReady(err);
+            reject(err);
+          }
+        });
+        child.once("exit", (code, signal) => {
+          if (!resolved) {
+            const err = new Error(
+              `${serverKind} server exited before binding (code=${code}, signal=${signal})`
+            );
+            rejectChildReady(err);
+            reject(err);
+          }
+        });
+      }).catch((err) => {
+        rejectChildReady(err);
+        reject(err);
+      });
+    });
+    const { port, pid } = await childReady;
+    PERSISTENT_SERVERS.set(serverKey, {
+      port,
+      pid,
+      child: childProcess,
+      stdoutLogListener,
+      stderrLogListener
+    });
+    const shutdown = async () => {
+    };
+    return { port, pid, shutdown };
+  } finally {
+    PENDING_STARTS.delete(serverKey);
+  }
+};
+
+// src/index.ts
+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_utils3.debug)("Downloading user files...");
-  let downloadedFiles = await (0, import_build_utils3.download)(files, workPath, meta);
+  (0, import_build_utils5.debug)("Downloading user files...");
+  let downloadedFiles = await (0, import_build_utils5.download)(files, workPath, meta);
   if (meta.isDev) {
-    const { devCacheDir = (0, import_path2.join)(workPath, ".now", "cache") } = meta;
-    const destCache = (0, import_path2.join)(devCacheDir, (0, import_path2.basename)(entrypoint, ".py"));
-    await (0, import_build_utils3.download)(downloadedFiles, destCache);
-    downloadedFiles = await (0, import_build_utils3.glob)("**", destCache);
+    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);
     workPath = destCache;
   }
   return workPath;
@@ -3166,7 +3615,6 @@ var build = async ({
   meta = {},
   config
 }) => {
-  let pythonVersion = getLatestPythonVersion(meta);
   workPath = await downloadFilesInWorkPath({
     workPath,
     files: originalFiles,
@@ -3175,98 +3623,91 @@ var build = async ({
   });
   try {
     if (meta.isDev) {
-      const setupCfg = (0, import_path2.join)(workPath, "setup.cfg");
+      const setupCfg = (0, import_path5.join)(workPath, "setup.cfg");
       await writeFile(setupCfg, "[install]\nprefix=\n");
     }
   } catch (err) {
     console.log('Failed to create "setup.cfg" file');
     throw err;
   }
-  let fsFiles = await (0, import_build_utils3.glob)("**", workPath);
-  if (!fsFiles[entrypoint]) {
-    let discovered;
-    if (config?.framework === "fastapi") {
-      const entrypointCandidates = fastapiCandidateEntrypoints.filter(
-        (c) => !!fsFiles[c]
+  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).`
       );
-      if (entrypointCandidates.length) {
-        const fastapiEntrypoint = entrypointCandidates.find(
-          (c) => isFastapiEntrypoint(fsFiles[c])
-        );
-        discovered = fastapiEntrypoint || entrypointCandidates[0];
-      }
-    }
-    if (discovered) {
-      (0, import_build_utils3.debug)(
-        `Resolved Python entrypoint to "${discovered}" (configured "${entrypoint}" not found).`
-      );
-      entrypoint = discovered;
-    } else if (config?.framework === "fastapi") {
-      const searchedList = fastapiCandidateEntrypoints.join(", ");
-      throw new import_build_utils3.NowBuildError({
+      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}`
       });
     }
   }
-  const entryDirectory = (0, import_path2.dirname)(entrypoint);
-  const hasReqLocal = !!fsFiles[(0, import_path2.join)(entryDirectory, "requirements.txt")];
+  const entryDirectory = (0, import_path5.dirname)(entrypoint);
+  const hasReqLocal = !!fsFiles[(0, import_path5.join)(entryDirectory, "requirements.txt")];
   const hasReqGlobal = !!fsFiles["requirements.txt"];
-  const pipfileLockDir = fsFiles[(0, import_path2.join)(entryDirectory, "Pipfile.lock")] ? (0, import_path2.join)(workPath, entryDirectory) : fsFiles["Pipfile.lock"] ? workPath : null;
-  const pipfileDir = fsFiles[(0, import_path2.join)(entryDirectory, "Pipfile")] ? (0, import_path2.join)(workPath, entryDirectory) : fsFiles["Pipfile"] ? workPath : null;
-  if (!hasReqLocal && !hasReqGlobal && (pipfileLockDir || pipfileDir)) {
-    if (pipfileLockDir) {
-      (0, import_build_utils3.debug)('Found "Pipfile.lock"');
-    } else {
-      (0, import_build_utils3.debug)('Found "Pipfile"');
+  const uvLockDir = findDir({
+    file: "uv.lock",
+    entryDirectory,
+    workPath,
+    fsFiles
+  });
+  const pyprojectDir = findDir({
+    file: "pyproject.toml",
+    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"));
+      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}"`
+      );
     }
-    if (pipfileLockDir) {
-      let lock = {};
-      try {
-        const json = await readFile(
-          (0, import_path2.join)(pipfileLockDir, "Pipfile.lock"),
-          "utf8"
-        );
-        lock = JSON.parse(json);
-      } catch (err) {
-        throw new import_build_utils3.NowBuildError({
-          code: "INVALID_PIPFILE_LOCK",
-          message: "Unable to parse Pipfile.lock"
-        });
-      }
-      pythonVersion = getSupportedPythonVersion({
-        isDev: meta.isDev,
-        pipLockPythonVersion: lock?._meta?.requires?.python_version
+  } else if (pipfileLockDir) {
+    let lock = {};
+    try {
+      const json = await readFile((0, import_path5.join)(pipfileLockDir, "Pipfile.lock"), "utf8");
+      lock = JSON.parse(json);
+    } catch (err) {
+      throw new import_build_utils5.NowBuildError({
+        code: "INVALID_PIPFILE_LOCK",
+        message: "Unable to parse Pipfile.lock"
       });
     }
-    if (!hasReqLocal && !hasReqGlobal) {
-      const tempDir = await (0, import_build_utils3.getWriteableDirectory)();
-      await installRequirement({
-        pythonPath: pythonVersion.pythonPath,
-        pipPath: pythonVersion.pipPath,
-        dependency: "pipfile-requirements",
-        version: "0.3.0",
-        workPath: tempDir,
-        meta,
-        args: ["--no-warn-script-location"]
-      });
-      const tempVendorDir = (0, import_path2.join)(tempDir, resolveVendorDir());
-      const envForConvert = { ...process.env, PYTHONPATH: tempVendorDir };
-      const convertCmd = process.platform === "win32" ? (0, import_path2.join)(tempVendorDir, "Scripts", "pipfile2req.exe") : (0, import_path2.join)(tempVendorDir, "bin", "pipfile2req");
-      await pipenvConvert(
-        convertCmd,
-        pipfileLockDir || pipfileDir,
-        envForConvert
-      );
-    } else {
-      (0, import_build_utils3.debug)(
-        'Skipping Pipfile.lock conversion because "requirements.txt" exists'
-      );
+    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`);
     }
   }
-  fsFiles = await (0, import_build_utils3.glob)("**", workPath);
-  const requirementsTxt = (0, import_path2.join)(entryDirectory, "requirements.txt");
-  const vendorBaseDir = (0, import_path2.join)(
+  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",
@@ -3274,49 +3715,150 @@ var build = async ({
     entryDirectory
   );
   try {
-    await import_fs2.default.promises.mkdir(vendorBaseDir, { recursive: true });
+    await import_fs5.default.promises.mkdir(vendorBaseDir, { recursive: true });
   } catch (err) {
     console.log("Failed to create vendor cache directory");
     throw err;
   }
-  console.log("Installing required dependencies...");
+  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({
     pythonPath: pythonVersion.pythonPath,
     pipPath: pythonVersion.pipPath,
+    uvPath,
     dependency: "werkzeug",
     version: "1.0.1",
-    workPath: vendorBaseDir,
+    workPath,
+    targetDir: vendorBaseDir,
     meta
   });
-  if (fsFiles[requirementsTxt]) {
-    (0, import_build_utils3.debug)('Found local "requirements.txt"');
+  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,
+        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"
+      );
+    }
+    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({
+        pythonPath: pythonVersion.pythonPath,
+        pipPath: pythonVersion.pipPath,
+        uvPath,
+        projectDir: pipfileLockDir || pipfileDir,
+        meta
+      });
+      await installRequirementsFile({
+        pythonPath: pythonVersion.pythonPath,
+        pipPath: pythonVersion.pipPath,
+        uvPath,
+        filePath: exportedReq,
+        workPath,
+        targetDir: vendorBaseDir,
+        meta
+      });
+      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: vendorBaseDir,
+      workPath,
+      targetDir: vendorBaseDir,
       meta
     });
-  } else if (fsFiles["requirements.txt"]) {
-    (0, import_build_utils3.debug)('Found global "requirements.txt"');
+  } 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: vendorBaseDir,
+      workPath,
+      targetDir: vendorBaseDir,
       meta
     });
   }
-  const originalPyPath = (0, import_path2.join)(__dirname, "..", "vc_init.py");
+  const originalPyPath = (0, import_path5.join)(__dirname, "..", "vc_init.py");
   const originalHandlerPyContents = await readFile(originalPyPath, "utf8");
-  (0, import_build_utils3.debug)("Entrypoint is", entrypoint);
-  const moduleName = entrypoint.replace(/\//g, ".").replace(/\.py$/, "");
+  (0, import_build_utils5.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_utils3.debug)("Entrypoint with suffix is", entrypointWithSuffix);
+  (0, import_build_utils5.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/**",
@@ -3328,7 +3870,8 @@ var build = async ({
     "**/.nuxt/**",
     "**/.venv/**",
     "**/venv/**",
-    "**/__pycache__/**"
+    "**/__pycache__/**",
+    "**/public/**"
   ];
   const lambdaEnv = {};
   lambdaEnv.PYTHONPATH = vendorDir;
@@ -3336,11 +3879,11 @@ var build = async ({
     cwd: workPath,
     ignore: config && typeof config.excludeFiles === "string" ? [...predefinedExcludes, config.excludeFiles] : predefinedExcludes
   };
-  const files = await (0, import_build_utils3.glob)("**", globOptions);
+  const files = await (0, import_build_utils5.glob)("**", globOptions);
   try {
-    const cachedVendorAbs = (0, import_path2.join)(vendorBaseDir, resolveVendorDir());
-    if (import_fs2.default.existsSync(cachedVendorAbs)) {
-      const vendorFiles = await (0, import_build_utils3.glob)("**", cachedVendorAbs, resolveVendorDir());
+    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;
       }
@@ -3350,12 +3893,12 @@ var build = async ({
     throw err;
   }
   const handlerPyFilename = "vc__handler__python";
-  files[`${handlerPyFilename}.py`] = new import_build_utils3.FileBlob({ data: handlerPyContents });
+  files[`${handlerPyFilename}.py`] = new import_build_utils5.FileBlob({ data: handlerPyContents });
   if (config.framework === "fasthtml") {
     const { SESSKEY = "" } = process.env;
-    files[".sesskey"] = new import_build_utils3.FileBlob({ data: `"${SESSKEY}"` });
+    files[".sesskey"] = new import_build_utils5.FileBlob({ data: `"${SESSKEY}"` });
   }
-  const output = new import_build_utils3.Lambda({
+  const output = new import_build_utils5.Lambda({
     files,
     handler: `${handlerPyFilename}.vc_handler`,
     runtime: pythonVersion.runtime,
@@ -3364,12 +3907,44 @@ var build = async ({
   });
   return { output };
 };
+var shouldServe = (opts) => {
+  const framework = opts.config.framework;
+  if (framework === "fastapi") {
+    const requestPath = opts.requestPath.replace(/\/$/, "");
+    if (requestPath.startsWith("api") && opts.hasMatched) {
+      return false;
+    }
+    return true;
+  }
+  return defaultShouldServe(opts);
+};
+var defaultShouldServe = ({
+  entrypoint,
+  files,
+  requestPath
+}) => {
+  requestPath = requestPath.replace(/\/$/, "");
+  entrypoint = entrypoint.replace(/\\/g, "/");
+  if (entrypoint === requestPath && hasProp(files, entrypoint)) {
+    return true;
+  }
+  const { dir, name } = (0, import_path5.parse)(entrypoint);
+  if (name === "index" && dir === requestPath && hasProp(files, entrypoint)) {
+    return true;
+  }
+  return false;
+};
+function hasProp(obj, key) {
+  return Object.hasOwnProperty.call(obj, key);
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   build,
+  defaultShouldServe,
   downloadFilesInWorkPath,
   installRequirement,
   installRequirementsFile,
   shouldServe,
+  startDevServer,
   version
 });